DataFrame:\n- # If multiindex, gather names of columns on all level for checking presence\n- # of `id_vars` and `value_vars`\n- if isinstance(frame.columns, MultiIndex):\n- cols = [x for c in frame.columns for x in c]\n- else:\n- cols = list(frame.columns)\n-\n- if value_name in frame.columns:\n- warnings.warn(\n- \"This dataframe has a column name that matches the 'value_name' column \"\n- \"name of the resulting Dataframe. \"\n- \"In the future this will raise an error, please set the 'value_name' \"\n- \"parameter of DataFrame.melt to a unique name.\",\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n-\n- if id_vars is not None:\n- if not is_list_like(id_vars):\n- id_vars = [id_vars]\n- elif isinstance(frame.columns, MultiIndex) and not isinstance(id_vars, list):\n- raise ValueError(\n- \"id_vars must be a list of tuples when columns are a MultiIndex\"\n- )\n- else:\n- # Check that `id_vars` are in frame\n- id_vars = list(id_vars)\n- missing = Index(com.flatten(id_vars)).difference(cols)\n- if not missing.empty:\n- raise KeyError(\n- \"The following 'id_vars' are not present \"\n- f\"in the DataFrame: {list(missing)}\"\n- )\n- else:\n- id_vars = []\n-\n- if value_vars is not None:\n- if not is_list_like(value_vars):\n- value_vars = [value_vars]\n- elif isinstance(frame.columns, MultiIndex) and not isinstance(value_vars, list):\n- raise ValueError(\n- \"value_vars must be a list of tuples when columns are a MultiIndex\"\n- )\n- else:\n- value_vars = list(value_vars)\n- # Check that `value_vars` are in frame\n- missing = Index(com.flatten(value_vars)).difference(cols)\n- if not missing.empty:\n- raise KeyError(\n- \"The following 'value_vars' are not present in \"\n- f\"the DataFrame: {list(missing)}\"\n- )\n- if col_level is not None:\n- idx = frame.columns.get_level_values(col_level).get_indexer(\n- id_vars + value_vars\n- )\n- else:\n- idx = algos.unique(frame.columns.get_indexer_for(id_vars + value_vars))\n- frame = frame.iloc[:, idx]\n- else:\n- frame = frame.copy()\n-\n- if col_level is not None: # allow list or other?\n- # frame is a copy\n- frame.columns = frame.columns.get_level_values(col_level)\n-\n- if var_name is None:\n- if isinstance(frame.columns, MultiIndex):\n- if len(frame.columns.names) == len(set(frame.columns.names)):\n- var_name = frame.columns.names\n- else:\n- var_name = [f\"variable_{i}\" for i in range(len(frame.columns.names))]\n- else:\n- var_name = [\n- frame.columns.name if frame.columns.name is not None else \"variable\"\n- ]\n- if isinstance(var_name, str):\n- var_name = [var_name]\n-\n- N, K = frame.shape\n- K -= len(id_vars)\n-\n- mdata = {}\n- for col in id_vars:\n- id_data = frame.pop(col)\n- if is_extension_array_dtype(id_data):\n- id_data = concat([id_data] * K, ignore_index=True)\n- else:\n- # error: Incompatible types in assignment (expression has type\n- # \"ndarray[Any, dtype[Any]]\", variable has type \"Series\")\n- id_data = np.tile(id_data._values, K) # type: ignore[assignment]\n- mdata[col] = id_data\n-\n- mcolumns = id_vars + var_name + [value_name]\n-\n- # error: Incompatible types in assignment (expression has type \"ndarray\",\n- # target has type \"Series\")\n- mdata[value_name] = frame._values.ravel(\"F\") # type: ignore[assignment]\n- for i, col in enumerate(var_name):\n- # asanyarray will keep the columns as an Index\n-\n- # error: Incompatible types in assignment (expression has type \"ndarray\", target\n- # has type \"Series\")\n- mdata[col] = np.asanyarray( # type: ignore[assignment]\n- frame.columns._get_level_values(i)\n- ).repeat(N)\n-\n- result = frame._constructor(mdata, columns=mcolumns)\n-\n- if not ignore_index:\n- result.index = tile_compat(frame.index, K)\n-\n- return result\n-\n-\n-@deprecate_kwarg(old_arg_name=\"label\", new_arg_name=None)\n-def lreshape(data: DataFrame, groups, dropna: bool = True, label=None) -> DataFrame:\n- \"\"\"\n- Reshape wide-format data to long. Generalized inverse of DataFrame.pivot.\n-\n- Accepts a dictionary, ``groups``, in which each key is a new column name\n- and each value is a list of old column names that will be \"melted\" under\n- the new column name as part of the reshape.\n-\n- Parameters\n- ----------\n- data : DataFrame\n- The wide-format DataFrame.\n- groups : dict\n- {new_name : list_of_columns}.\n- dropna : bool, default True\n- Do not include columns whose entries are all NaN.\n- label : None\n- Not used.\n-\n- .. deprecated:: 1.0.0\n-\n- Returns\n- -------\n- DataFrame\n- Reshaped DataFrame.\n-\n- See Also\n- --------\n- melt : Unpivot a DataFrame from wide to long format, optionally leaving\n- identifiers set.\n- pivot : Create a spreadsheet-style pivot table as a DataFrame.\n- DataFrame.pivot : Pivot without aggregation that can handle\n- non-numeric data.\n- DataFrame.pivot_table : Generalization of pivot that can handle\n- duplicate values for one index/column pair.\n- DataFrame.unstack : Pivot based on the index values instead of a\n- column.\n- wide_to_long : Wide panel to long format. Less flexible but more\n- user-friendly than melt.\n-\n- Examples\n- --------\n- >>> data = pd.DataFrame({'hr1': [514, 573], 'hr2': [545, 526],\n- ... 'team': ['Red Sox', 'Yankees'],\n- ... 'year1': [2007, 2007], 'year2': [2008, 2008]})\n- >>> data\n- hr1 hr2 team year1 year2\n- 0 514 545 Red Sox 2007 2008\n- 1 573 526 Yankees 2007 2008\n-\n- >>> pd.lreshape(data, {'year': ['year1', 'year2'], 'hr': ['hr1', 'hr2']})\n- team year hr\n- 0 Red Sox 2007 514\n- 1 Yankees 2007 573\n- 2 Red Sox 2008 545\n- 3 Yankees 2008 526\n- \"\"\"\n- if isinstance(groups, dict):\n- keys = list(groups.keys())\n- values = list(groups.values())\n- else:\n- keys, values = zip(*groups)\n-\n- all_cols = list(set.union(*(set(x) for x in values)))\n- id_cols = list(data.columns.difference(all_cols))\n-\n- K = len(values[0])\n-\n- for seq in values:\n- if len(seq) != K:\n- raise ValueError(\"All column lists must be same length\")\n-\n- mdata = {}\n- pivot_cols = []\n-\n- for target, names in zip(keys, values):\n- to_concat = [data[col]._values for col in names]\n-\n- mdata[target] = concat_compat(to_concat)\n- pivot_cols.append(target)\n-\n- for col in id_cols:\n- mdata[col] = np.tile(data[col]._values, K)\n-\n- if dropna:\n- mask = np.ones(len(mdata[pivot_cols[0]]), dtype=bool)\n- for c in pivot_cols:\n- mask &= notna(mdata[c])\n- if not mask.all():\n- mdata = {k: v[mask] for k, v in mdata.items()}\n-\n- return data._constructor(mdata, columns=id_cols + pivot_cols)\n-\n-\n-def wide_to_long(\n- df: DataFrame, stubnames, i, j, sep: str = \"\", suffix: str = r\"\\d+\"\n-) -> DataFrame:\n- r\"\"\"\n- Unpivot a DataFrame from wide to long format.\n-\n- Less flexible but more user-friendly than melt.\n-\n- With stubnames ['A', 'B'], this function expects to find one or more\n- group of columns with format\n- A-suffix1, A-suffix2,..., B-suffix1, B-suffix2,...\n- You specify what you want to call this suffix in the resulting long format\n- with `j` (for example `j='year'`)\n-\n- Each row of these wide variables are assumed to be uniquely identified by\n- `i` (can be a single column name or a list of column names)\n-\n- All remaining variables in the data frame are left intact.\n-\n- Parameters\n- ----------\n- df : DataFrame\n- The wide-format DataFrame.\n- stubnames : str or list-like\n- The stub name(s). The wide format variables are assumed to\n- start with the stub names.\n- i : str or list-like\n- Column(s) to use as id variable(s).\n- j : str\n- The name of the sub-observation variable. What you wish to name your\n- suffix in the long format.\n- sep : str, default \"\"\n- A character indicating the separation of the variable names\n- in the wide format, to be stripped from the names in the long format.\n- For example, if your column names are A-suffix1, A-suffix2, you\n- can strip the hyphen by specifying `sep='-'`.\n- suffix : str, default '\\\\d+'\n- A regular expression capturing the wanted suffixes. '\\\\d+' captures\n- numeric suffixes. Suffixes with no numbers could be specified with the\n- negated character class '\\\\D+'. You can also further disambiguate\n- suffixes, for example, if your wide variables are of the form A-one,\n- B-two,.., and you have an unrelated column A-rating, you can ignore the\n- last one by specifying `suffix='(!?one|two)'`. When all suffixes are\n- numeric, they are cast to int64/float64.\n-\n- Returns\n- -------\n- DataFrame\n- A DataFrame that contains each stub name as a variable, with new index\n- (i, j).\n-\n- See Also\n- --------\n- melt : Unpivot a DataFrame from wide to long format, optionally leaving\n- identifiers set.\n- pivot : Create a spreadsheet-style pivot table as a DataFrame.\n- DataFrame.pivot : Pivot without aggregation that can handle\n- non-numeric data.\n- DataFrame.pivot_table : Generalization of pivot that can handle\n- duplicate values for one index/column pair.\n- DataFrame.unstack : Pivot based on the index values instead of a\n- column.\n-\n- Notes\n- -----\n- All extra variables are left untouched. This simply uses\n- `pandas.melt` under the hood, but is hard-coded to \"do the right thing\"\n- in a typical case.\n-\n- Examples\n- --------\n- >>> np.random.seed(123)\n- >>> df = pd.DataFrame({\"A1970\" : {0 : \"a\", 1 : \"b\", 2 : \"c\"},\n- ... \"A1980\" : {0 : \"d\", 1 : \"e\", 2 : \"f\"},\n- ... \"B1970\" : {0 : 2.5, 1 : 1.2, 2 : .7},\n- ... \"B1980\" : {0 : 3.2, 1 : 1.3, 2 : .1},\n- ... \"X\" : dict(zip(range(3), np.random.randn(3)))\n- ... })\n- >>> df[\"id\"] = df.index\n- >>> df\n- A1970 A1980 B1970 B1980 X id\n- 0 a d 2.5 3.2 -1.085631 0\n- 1 b e 1.2 1.3 0.997345 1\n- 2 c f 0.7 0.1 0.282978 2\n- >>> pd.wide_to_long(df, [\"A\", \"B\"], i=\"id\", j=\"year\")\n- ... # doctest: +NORMALIZE_WHITESPACE\n- X A B\n- id year\n- 0 1970 -1.085631 a 2.5\n- 1 1970 0.997345 b 1.2\n- 2 1970 0.282978 c 0.7\n- 0 1980 -1.085631 d 3.2\n- 1 1980 0.997345 e 1.3\n- 2 1980 0.282978 f 0.1\n-\n- With multiple id columns\n-\n- >>> df = pd.DataFrame({\n- ... 'famid': [1, 1, 1, 2, 2, 2, 3, 3, 3],\n- ... 'birth': [1, 2, 3, 1, 2, 3, 1, 2, 3],\n- ... 'ht1': [2.8, 2.9, 2.2, 2, 1.8, 1.9, 2.2, 2.3, 2.1],\n- ... 'ht2': [3.4, 3.8, 2.9, 3.2, 2.8, 2.4, 3.3, 3.4, 2.9]\n- ... })\n- >>> df\n- famid birth ht1 ht2\n- 0 1 1 2.8 3.4\n- 1 1 2 2.9 3.8\n- 2 1 3 2.2 2.9\n- 3 2 1 2.0 3.2\n- 4 2 2 1.8 2.8\n- 5 2 3 1.9 2.4\n- 6 3 1 2.2 3.3\n- 7 3 2 2.3 3.4\n- 8 3 3 2.1 2.9\n- >>> l = pd.wide_to_long(df, stubnames='ht', i=['famid', 'birth'], j='age')\n- >>> l\n- ... # doctest: +NORMALIZE_WHITESPACE\n- ht\n- famid birth age\n- 1 1 1 2.8\n- 2 3.4\n- 2 1 2.9\n- 2 3.8\n- 3 1 2.2\n- 2 2.9\n- 2 1 1 2.0\n- 2 3.2\n- 2 1 1.8\n- 2 2.8\n- 3 1 1.9\n- 2 2.4\n- 3 1 1 2.2\n- 2 3.3\n- 2 1 2.3\n- 2 3.4\n- 3 1 2.1\n- 2 2.9\n-\n- Going from long back to wide just takes some creative use of `unstack`\n-\n- >>> w = l.unstack()\n- >>> w.columns = w.columns.map('{0[0]}{0[1]}'.format)\n- >>> w.reset_index()\n- famid birth ht1 ht2\n- 0 1 1 2.8 3.4\n- 1 1 2 2.9 3.8\n- 2 1 3 2.2 2.9\n- 3 2 1 2.0 3.2\n- 4 2 2 1.8 2.8\n- 5 2 3 1.9 2.4\n- 6 3 1 2.2 3.3\n- 7 3 2 2.3 3.4\n- 8 3 3 2.1 2.9\n-\n- Less wieldy column names are also handled\n-\n- >>> np.random.seed(0)\n- >>> df = pd.DataFrame({'A(weekly)-2010': np.random.rand(3),\n- ... 'A(weekly)-2011': np.random.rand(3),\n- ... 'B(weekly)-2010': np.random.rand(3),\n- ... 'B(weekly)-2011': np.random.rand(3),\n- ... 'X' : np.random.randint(3, size=3)})\n- >>> df['id'] = df.index\n- >>> df # doctest: +NORMALIZE_WHITESPACE, +ELLIPSIS\n- A(weekly)-2010 A(weekly)-2011 B(weekly)-2010 B(weekly)-2011 X id\n- 0 0.548814 0.544883 0.437587 0.383442 0 0\n- 1 0.715189 0.423655 0.891773 0.791725 1 1\n- 2 0.602763 0.645894 0.963663 0.528895 1 2\n-\n- >>> pd.wide_to_long(df, ['A(weekly)', 'B(weekly)'], i='id',\n- ... j='year', sep='-')\n- ... # doctest: +NORMALIZE_WHITESPACE\n- X A(weekly) B(weekly)\n- id year\n- 0 2010 0 0.548814 0.437587\n- 1 2010 1 0.715189 0.891773\n- 2 2010 1 0.602763 0.963663\n- 0 2011 0 0.544883 0.383442\n- 1 2011 1 0.423655 0.791725\n- 2 2011 1 0.645894 0.528895\n-\n- If we have many columns, we could also use a regex to find our\n- stubnames and pass that list on to wide_to_long\n-\n- >>> stubnames = sorted(\n- ... set([match[0] for match in df.columns.str.findall(\n- ... r'[A-B]\\(.*\\)').values if match != []])\n- ... )\n- >>> list(stubnames)\n- ['A(weekly)', 'B(weekly)']\n-\n- All of the above examples have integers as suffixes. It is possible to\n- have non-integers as suffixes.\n-\n- >>> df = pd.DataFrame({\n- ... 'famid': [1, 1, 1, 2, 2, 2, 3, 3, 3],\n- ... 'birth': [1, 2, 3, 1, 2, 3, 1, 2, 3],\n- ... 'ht_one': [2.8, 2.9, 2.2, 2, 1.8, 1.9, 2.2, 2.3, 2.1],\n- ... 'ht_two': [3.4, 3.8, 2.9, 3.2, 2.8, 2.4, 3.3, 3.4, 2.9]\n- ... })\n- >>> df\n- famid birth ht_one ht_two\n- 0 1 1 2.8 3.4\n- 1 1 2 2.9 3.8\n- 2 1 3 2.2 2.9\n- 3 2 1 2.0 3.2\n- 4 2 2 1.8 2.8\n- 5 2 3 1.9 2.4\n- 6 3 1 2.2 3.3\n- 7 3 2 2.3 3.4\n- 8 3 3 2.1 2.9\n-\n- >>> l = pd.wide_to_long(df, stubnames='ht', i=['famid', 'birth'], j='age',\n- ... sep='_', suffix=r'\\w+')\n- >>> l\n- ... # doctest: +NORMALIZE_WHITESPACE\n- ht\n- famid birth age\n- 1 1 one 2.8\n- two 3.4\n- 2 one 2.9\n- two 3.8\n- 3 one 2.2\n- two 2.9\n- 2 1 one 2.0\n- two 3.2\n- 2 one 1.8\n- two 2.8\n- 3 one 1.9\n- two 2.4\n- 3 1 one 2.2\n- two 3.3\n- 2 one 2.3\n- two 3.4\n- 3 one 2.1\n- two 2.9\n- \"\"\"\n-\n- def get_var_names(df, stub: str, sep: str, suffix: str) -> list[str]:\n- regex = rf\"^{re.escape(stub)}{re.escape(sep)}{suffix}$\"\n- pattern = re.compile(regex)\n- return [col for col in df.columns if pattern.match(col)]\n-\n- def melt_stub(df, stub: str, i, j, value_vars, sep: str):\n- newdf = melt(\n- df,\n- id_vars=i,\n- value_vars=value_vars,\n- value_name=stub.rstrip(sep),\n- var_name=j,\n- )\n- newdf[j] = Categorical(newdf[j])\n- newdf[j] = newdf[j].str.replace(re.escape(stub + sep), \"\", regex=True)\n-\n- # GH17627 Cast numerics suffixes to int/float\n- newdf[j] = to_numeric(newdf[j], errors=\"ignore\")\n-\n- return newdf.set_index(i + [j])\n-\n- if not is_list_like(stubnames):\n- stubnames = [stubnames]\n- else:\n- stubnames = list(stubnames)\n-\n- if any(col in stubnames for col in df.columns):\n- raise ValueError(\"stubname can't be identical to a column name\")\n-\n- if not is_list_like(i):\n- i = [i]\n- else:\n- i = list(i)\n-\n- if df[i].duplicated().any():\n- raise ValueError(\"the id variables need to uniquely identify each row\")\n-\n- value_vars = [get_var_names(df, stub, sep, suffix) for stub in stubnames]\n-\n- value_vars_flattened = [e for sublist in value_vars for e in sublist]\n- id_vars = list(set(df.columns.tolist()).difference(value_vars_flattened))\n-\n- _melted = [melt_stub(df, s, i, j, v, sep) for s, v in zip(stubnames, value_vars)]\n- melted = _melted[0].join(_melted[1:], how=\"outer\")\n-\n- if len(i) == 1:\n- new = df[id_vars].set_index(i).join(melted)\n- return new\n-\n- new = df[id_vars].merge(melted.reset_index(), on=i).set_index(i + [j])\n-\n- return new\n+from pandas._core.reshape.melt import *\ndiff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py\nindex 6ce5ffac9de52..811b5e0baab43 100644\n--- a/pandas/core/reshape/merge.py\n+++ b/pandas/core/reshape/merge.py\n@@ -1,2425 +1 @@\n-\"\"\"\n-SQL-style merge routines\n-\"\"\"\n-from __future__ import annotations\n-\n-import copy\n-import datetime\n-from functools import partial\n-import hashlib\n-import string\n-from typing import (\n- TYPE_CHECKING,\n- Hashable,\n- cast,\n-)\n-import warnings\n-\n-import numpy as np\n-\n-from pandas._libs import (\n- Timedelta,\n- hashtable as libhashtable,\n- join as libjoin,\n- lib,\n-)\n-from pandas._typing import (\n- ArrayLike,\n- DtypeObj,\n- IndexLabel,\n- Suffixes,\n- npt,\n-)\n-from pandas.errors import MergeError\n-from pandas.util._decorators import (\n- Appender,\n- Substitution,\n-)\n-from pandas.util._exceptions import find_stack_level\n-\n-from pandas.core.dtypes.cast import find_common_type\n-from pandas.core.dtypes.common import (\n- ensure_float64,\n- ensure_int64,\n- ensure_object,\n- is_array_like,\n- is_bool,\n- is_bool_dtype,\n- is_categorical_dtype,\n- is_datetime64tz_dtype,\n- is_dtype_equal,\n- is_extension_array_dtype,\n- is_float_dtype,\n- is_integer,\n- is_integer_dtype,\n- is_list_like,\n- is_number,\n- is_numeric_dtype,\n- is_object_dtype,\n- needs_i8_conversion,\n-)\n-from pandas.core.dtypes.generic import (\n- ABCDataFrame,\n- ABCSeries,\n-)\n-from pandas.core.dtypes.missing import (\n- isna,\n- na_value_for_dtype,\n-)\n-\n-from pandas import (\n- Categorical,\n- Index,\n- MultiIndex,\n- Series,\n-)\n-from pandas.core import groupby\n-import pandas.core.algorithms as algos\n-from pandas.core.arrays import ExtensionArray\n-from pandas.core.arrays._mixins import NDArrayBackedExtensionArray\n-import pandas.core.common as com\n-from pandas.core.construction import extract_array\n-from pandas.core.frame import _merge_doc\n-from pandas.core.internals import concatenate_managers\n-from pandas.core.sorting import is_int64_overflow_possible\n-\n-if TYPE_CHECKING:\n- from pandas import DataFrame\n- from pandas.core.arrays import DatetimeArray\n-\n-\n-@Substitution(\"\\nleft : DataFrame or named Series\")\n-@Appender(_merge_doc, indents=0)\n-def merge(\n- left: DataFrame | Series,\n- right: DataFrame | Series,\n- how: str = \"inner\",\n- on: IndexLabel | None = None,\n- left_on: IndexLabel | None = None,\n- right_on: IndexLabel | None = None,\n- left_index: bool = False,\n- right_index: bool = False,\n- sort: bool = False,\n- suffixes: Suffixes = (\"_x\", \"_y\"),\n- copy: bool = True,\n- indicator: bool = False,\n- validate: str | None = None,\n-) -> DataFrame:\n- op = _MergeOperation(\n- left,\n- right,\n- how=how,\n- on=on,\n- left_on=left_on,\n- right_on=right_on,\n- left_index=left_index,\n- right_index=right_index,\n- sort=sort,\n- suffixes=suffixes,\n- copy=copy,\n- indicator=indicator,\n- validate=validate,\n- )\n- return op.get_result()\n-\n-\n-if __debug__:\n- merge.__doc__ = _merge_doc % \"\\nleft : DataFrame\"\n-\n-\n-def _groupby_and_merge(by, left: DataFrame, right: DataFrame, merge_pieces):\n- \"\"\"\n- groupby & merge; we are always performing a left-by type operation\n-\n- Parameters\n- ----------\n- by: field to group\n- left: DataFrame\n- right: DataFrame\n- merge_pieces: function for merging\n- \"\"\"\n- pieces = []\n- if not isinstance(by, (list, tuple)):\n- by = [by]\n-\n- lby = left.groupby(by, sort=False)\n- rby: groupby.DataFrameGroupBy | None = None\n-\n- # if we can groupby the rhs\n- # then we can get vastly better perf\n- if all(item in right.columns for item in by):\n- rby = right.groupby(by, sort=False)\n-\n- for key, lhs in lby:\n-\n- if rby is None:\n- rhs = right\n- else:\n- try:\n- rhs = right.take(rby.indices[key])\n- except KeyError:\n- # key doesn't exist in left\n- lcols = lhs.columns.tolist()\n- cols = lcols + [r for r in right.columns if r not in set(lcols)]\n- merged = lhs.reindex(columns=cols)\n- merged.index = range(len(merged))\n- pieces.append(merged)\n- continue\n-\n- merged = merge_pieces(lhs, rhs)\n-\n- # make sure join keys are in the merged\n- # TODO, should merge_pieces do this?\n- merged[by] = key\n-\n- pieces.append(merged)\n-\n- # preserve the original order\n- # if we have a missing piece this can be reset\n- from pandas.core.reshape.concat import concat\n-\n- result = concat(pieces, ignore_index=True)\n- result = result.reindex(columns=pieces[0].columns, copy=False)\n- return result, lby\n-\n-\n-def merge_ordered(\n- left: DataFrame,\n- right: DataFrame,\n- on: IndexLabel | None = None,\n- left_on: IndexLabel | None = None,\n- right_on: IndexLabel | None = None,\n- left_by=None,\n- right_by=None,\n- fill_method: str | None = None,\n- suffixes: Suffixes = (\"_x\", \"_y\"),\n- how: str = \"outer\",\n-) -> DataFrame:\n- \"\"\"\n- Perform a merge for ordered data with optional filling/interpolation.\n-\n- Designed for ordered data like time series data. Optionally\n- perform group-wise merge (see examples).\n-\n- Parameters\n- ----------\n- left : DataFrame\n- right : DataFrame\n- on : label or list\n- Field names to join on. Must be found in both DataFrames.\n- left_on : label or list, or array-like\n- Field names to join on in left DataFrame. Can be a vector or list of\n- vectors of the length of the DataFrame to use a particular vector as\n- the join key instead of columns.\n- right_on : label or list, or array-like\n- Field names to join on in right DataFrame or vector/list of vectors per\n- left_on docs.\n- left_by : column name or list of column names\n- Group left DataFrame by group columns and merge piece by piece with\n- right DataFrame.\n- right_by : column name or list of column names\n- Group right DataFrame by group columns and merge piece by piece with\n- left DataFrame.\n- fill_method : {'ffill', None}, default None\n- Interpolation method for data.\n- suffixes : list-like, default is (\"_x\", \"_y\")\n- A length-2 sequence where each element is optionally a string\n- indicating the suffix to add to overlapping column names in\n- `left` and `right` respectively. Pass a value of `None` instead\n- of a string to indicate that the column name from `left` or\n- `right` should be left as-is, with no suffix. At least one of the\n- values must not be None.\n-\n- .. versionchanged:: 0.25.0\n- how : {'left', 'right', 'outer', 'inner'}, default 'outer'\n- * left: use only keys from left frame (SQL: left outer join)\n- * right: use only keys from right frame (SQL: right outer join)\n- * outer: use union of keys from both frames (SQL: full outer join)\n- * inner: use intersection of keys from both frames (SQL: inner join).\n-\n- Returns\n- -------\n- DataFrame\n- The merged DataFrame output type will the be same as\n- 'left', if it is a subclass of DataFrame.\n-\n- See Also\n- --------\n- merge : Merge with a database-style join.\n- merge_asof : Merge on nearest keys.\n-\n- Examples\n- --------\n- >>> df1 = pd.DataFrame(\n- ... {\n- ... \"key\": [\"a\", \"c\", \"e\", \"a\", \"c\", \"e\"],\n- ... \"lvalue\": [1, 2, 3, 1, 2, 3],\n- ... \"group\": [\"a\", \"a\", \"a\", \"b\", \"b\", \"b\"]\n- ... }\n- ... )\n- >>> df1\n- key lvalue group\n- 0 a 1 a\n- 1 c 2 a\n- 2 e 3 a\n- 3 a 1 b\n- 4 c 2 b\n- 5 e 3 b\n-\n- >>> df2 = pd.DataFrame({\"key\": [\"b\", \"c\", \"d\"], \"rvalue\": [1, 2, 3]})\n- >>> df2\n- key rvalue\n- 0 b 1\n- 1 c 2\n- 2 d 3\n-\n- >>> merge_ordered(df1, df2, fill_method=\"ffill\", left_by=\"group\")\n- key lvalue group rvalue\n- 0 a 1 a NaN\n- 1 b 1 a 1.0\n- 2 c 2 a 2.0\n- 3 d 2 a 3.0\n- 4 e 3 a 3.0\n- 5 a 1 b NaN\n- 6 b 1 b 1.0\n- 7 c 2 b 2.0\n- 8 d 2 b 3.0\n- 9 e 3 b 3.0\n- \"\"\"\n-\n- def _merger(x, y) -> DataFrame:\n- # perform the ordered merge operation\n- op = _OrderedMerge(\n- x,\n- y,\n- on=on,\n- left_on=left_on,\n- right_on=right_on,\n- suffixes=suffixes,\n- fill_method=fill_method,\n- how=how,\n- )\n- return op.get_result()\n-\n- if left_by is not None and right_by is not None:\n- raise ValueError(\"Can only group either left or right frames\")\n- elif left_by is not None:\n- if isinstance(left_by, str):\n- left_by = [left_by]\n- check = set(left_by).difference(left.columns)\n- if len(check) != 0:\n- raise KeyError(f\"{check} not found in left columns\")\n- result, _ = _groupby_and_merge(left_by, left, right, lambda x, y: _merger(x, y))\n- elif right_by is not None:\n- if isinstance(right_by, str):\n- right_by = [right_by]\n- check = set(right_by).difference(right.columns)\n- if len(check) != 0:\n- raise KeyError(f\"{check} not found in right columns\")\n- result, _ = _groupby_and_merge(\n- right_by, right, left, lambda x, y: _merger(y, x)\n- )\n- else:\n- result = _merger(left, right)\n- return result\n-\n-\n-def merge_asof(\n- left: DataFrame | Series,\n- right: DataFrame | Series,\n- on: IndexLabel | None = None,\n- left_on: IndexLabel | None = None,\n- right_on: IndexLabel | None = None,\n- left_index: bool = False,\n- right_index: bool = False,\n- by=None,\n- left_by=None,\n- right_by=None,\n- suffixes: Suffixes = (\"_x\", \"_y\"),\n- tolerance=None,\n- allow_exact_matches: bool = True,\n- direction: str = \"backward\",\n-) -> DataFrame:\n- \"\"\"\n- Perform a merge by key distance.\n-\n- This is similar to a left-join except that we match on nearest\n- key rather than equal keys. Both DataFrames must be sorted by the key.\n-\n- For each row in the left DataFrame:\n-\n- - A \"backward\" search selects the last row in the right DataFrame whose\n- 'on' key is less than or equal to the left's key.\n-\n- - A \"forward\" search selects the first row in the right DataFrame whose\n- 'on' key is greater than or equal to the left's key.\n-\n- - A \"nearest\" search selects the row in the right DataFrame whose 'on'\n- key is closest in absolute distance to the left's key.\n-\n- The default is \"backward\" and is compatible in versions below 0.20.0.\n- The direction parameter was added in version 0.20.0 and introduces\n- \"forward\" and \"nearest\".\n-\n- Optionally match on equivalent keys with 'by' before searching with 'on'.\n-\n- Parameters\n- ----------\n- left : DataFrame or named Series\n- right : DataFrame or named Series\n- on : label\n- Field name to join on. Must be found in both DataFrames.\n- The data MUST be ordered. Furthermore this must be a numeric column,\n- such as datetimelike, integer, or float. On or left_on/right_on\n- must be given.\n- left_on : label\n- Field name to join on in left DataFrame.\n- right_on : label\n- Field name to join on in right DataFrame.\n- left_index : bool\n- Use the index of the left DataFrame as the join key.\n- right_index : bool\n- Use the index of the right DataFrame as the join key.\n- by : column name or list of column names\n- Match on these columns before performing merge operation.\n- left_by : column name\n- Field names to match on in the left DataFrame.\n- right_by : column name\n- Field names to match on in the right DataFrame.\n- suffixes : 2-length sequence (tuple, list, ...)\n- Suffix to apply to overlapping column names in the left and right\n- side, respectively.\n- tolerance : int or Timedelta, optional, default None\n- Select asof tolerance within this range; must be compatible\n- with the merge index.\n- allow_exact_matches : bool, default True\n-\n- - If True, allow matching with the same 'on' value\n- (i.e. less-than-or-equal-to / greater-than-or-equal-to)\n- - If False, don't match the same 'on' value\n- (i.e., strictly less-than / strictly greater-than).\n-\n- direction : 'backward' (default), 'forward', or 'nearest'\n- Whether to search for prior, subsequent, or closest matches.\n-\n- Returns\n- -------\n- merged : DataFrame\n-\n- See Also\n- --------\n- merge : Merge with a database-style join.\n- merge_ordered : Merge with optional filling/interpolation.\n-\n- Examples\n- --------\n- >>> left = pd.DataFrame({\"a\": [1, 5, 10], \"left_val\": [\"a\", \"b\", \"c\"]})\n- >>> left\n- a left_val\n- 0 1 a\n- 1 5 b\n- 2 10 c\n-\n- >>> right = pd.DataFrame({\"a\": [1, 2, 3, 6, 7], \"right_val\": [1, 2, 3, 6, 7]})\n- >>> right\n- a right_val\n- 0 1 1\n- 1 2 2\n- 2 3 3\n- 3 6 6\n- 4 7 7\n-\n- >>> pd.merge_asof(left, right, on=\"a\")\n- a left_val right_val\n- 0 1 a 1\n- 1 5 b 3\n- 2 10 c 7\n-\n- >>> pd.merge_asof(left, right, on=\"a\", allow_exact_matches=False)\n- a left_val right_val\n- 0 1 a NaN\n- 1 5 b 3.0\n- 2 10 c 7.0\n-\n- >>> pd.merge_asof(left, right, on=\"a\", direction=\"forward\")\n- a left_val right_val\n- 0 1 a 1.0\n- 1 5 b 6.0\n- 2 10 c NaN\n-\n- >>> pd.merge_asof(left, right, on=\"a\", direction=\"nearest\")\n- a left_val right_val\n- 0 1 a 1\n- 1 5 b 6\n- 2 10 c 7\n-\n- We can use indexed DataFrames as well.\n-\n- >>> left = pd.DataFrame({\"left_val\": [\"a\", \"b\", \"c\"]}, index=[1, 5, 10])\n- >>> left\n- left_val\n- 1 a\n- 5 b\n- 10 c\n-\n- >>> right = pd.DataFrame({\"right_val\": [1, 2, 3, 6, 7]}, index=[1, 2, 3, 6, 7])\n- >>> right\n- right_val\n- 1 1\n- 2 2\n- 3 3\n- 6 6\n- 7 7\n-\n- >>> pd.merge_asof(left, right, left_index=True, right_index=True)\n- left_val right_val\n- 1 a 1\n- 5 b 3\n- 10 c 7\n-\n- Here is a real-world times-series example\n-\n- >>> quotes = pd.DataFrame(\n- ... {\n- ... \"time\": [\n- ... pd.Timestamp(\"2016-05-25 13:30:00.023\"),\n- ... pd.Timestamp(\"2016-05-25 13:30:00.023\"),\n- ... pd.Timestamp(\"2016-05-25 13:30:00.030\"),\n- ... pd.Timestamp(\"2016-05-25 13:30:00.041\"),\n- ... pd.Timestamp(\"2016-05-25 13:30:00.048\"),\n- ... pd.Timestamp(\"2016-05-25 13:30:00.049\"),\n- ... pd.Timestamp(\"2016-05-25 13:30:00.072\"),\n- ... pd.Timestamp(\"2016-05-25 13:30:00.075\")\n- ... ],\n- ... \"ticker\": [\n- ... \"GOOG\",\n- ... \"MSFT\",\n- ... \"MSFT\",\n- ... \"MSFT\",\n- ... \"GOOG\",\n- ... \"AAPL\",\n- ... \"GOOG\",\n- ... \"MSFT\"\n- ... ],\n- ... \"bid\": [720.50, 51.95, 51.97, 51.99, 720.50, 97.99, 720.50, 52.01],\n- ... \"ask\": [720.93, 51.96, 51.98, 52.00, 720.93, 98.01, 720.88, 52.03]\n- ... }\n- ... )\n- >>> quotes\n- time ticker bid ask\n- 0 2016-05-25 13:30:00.023 GOOG 720.50 720.93\n- 1 2016-05-25 13:30:00.023 MSFT 51.95 51.96\n- 2 2016-05-25 13:30:00.030 MSFT 51.97 51.98\n- 3 2016-05-25 13:30:00.041 MSFT 51.99 52.00\n- 4 2016-05-25 13:30:00.048 GOOG 720.50 720.93\n- 5 2016-05-25 13:30:00.049 AAPL 97.99 98.01\n- 6 2016-05-25 13:30:00.072 GOOG 720.50 720.88\n- 7 2016-05-25 13:30:00.075 MSFT 52.01 52.03\n-\n- >>> trades = pd.DataFrame(\n- ... {\n- ... \"time\": [\n- ... pd.Timestamp(\"2016-05-25 13:30:00.023\"),\n- ... pd.Timestamp(\"2016-05-25 13:30:00.038\"),\n- ... pd.Timestamp(\"2016-05-25 13:30:00.048\"),\n- ... pd.Timestamp(\"2016-05-25 13:30:00.048\"),\n- ... pd.Timestamp(\"2016-05-25 13:30:00.048\")\n- ... ],\n- ... \"ticker\": [\"MSFT\", \"MSFT\", \"GOOG\", \"GOOG\", \"AAPL\"],\n- ... \"price\": [51.95, 51.95, 720.77, 720.92, 98.0],\n- ... \"quantity\": [75, 155, 100, 100, 100]\n- ... }\n- ... )\n- >>> trades\n- time ticker price quantity\n- 0 2016-05-25 13:30:00.023 MSFT 51.95 75\n- 1 2016-05-25 13:30:00.038 MSFT 51.95 155\n- 2 2016-05-25 13:30:00.048 GOOG 720.77 100\n- 3 2016-05-25 13:30:00.048 GOOG 720.92 100\n- 4 2016-05-25 13:30:00.048 AAPL 98.00 100\n-\n- By default we are taking the asof of the quotes\n-\n- >>> pd.merge_asof(trades, quotes, on=\"time\", by=\"ticker\")\n- time ticker price quantity bid ask\n- 0 2016-05-25 13:30:00.023 MSFT 51.95 75 51.95 51.96\n- 1 2016-05-25 13:30:00.038 MSFT 51.95 155 51.97 51.98\n- 2 2016-05-25 13:30:00.048 GOOG 720.77 100 720.50 720.93\n- 3 2016-05-25 13:30:00.048 GOOG 720.92 100 720.50 720.93\n- 4 2016-05-25 13:30:00.048 AAPL 98.00 100 NaN NaN\n-\n- We only asof within 2ms between the quote time and the trade time\n-\n- >>> pd.merge_asof(\n- ... trades, quotes, on=\"time\", by=\"ticker\", tolerance=pd.Timedelta(\"2ms\")\n- ... )\n- time ticker price quantity bid ask\n- 0 2016-05-25 13:30:00.023 MSFT 51.95 75 51.95 51.96\n- 1 2016-05-25 13:30:00.038 MSFT 51.95 155 NaN NaN\n- 2 2016-05-25 13:30:00.048 GOOG 720.77 100 720.50 720.93\n- 3 2016-05-25 13:30:00.048 GOOG 720.92 100 720.50 720.93\n- 4 2016-05-25 13:30:00.048 AAPL 98.00 100 NaN NaN\n-\n- We only asof within 10ms between the quote time and the trade time\n- and we exclude exact matches on time. However *prior* data will\n- propagate forward\n-\n- >>> pd.merge_asof(\n- ... trades,\n- ... quotes,\n- ... on=\"time\",\n- ... by=\"ticker\",\n- ... tolerance=pd.Timedelta(\"10ms\"),\n- ... allow_exact_matches=False\n- ... )\n- time ticker price quantity bid ask\n- 0 2016-05-25 13:30:00.023 MSFT 51.95 75 NaN NaN\n- 1 2016-05-25 13:30:00.038 MSFT 51.95 155 51.97 51.98\n- 2 2016-05-25 13:30:00.048 GOOG 720.77 100 NaN NaN\n- 3 2016-05-25 13:30:00.048 GOOG 720.92 100 NaN NaN\n- 4 2016-05-25 13:30:00.048 AAPL 98.00 100 NaN NaN\n- \"\"\"\n- op = _AsOfMerge(\n- left,\n- right,\n- on=on,\n- left_on=left_on,\n- right_on=right_on,\n- left_index=left_index,\n- right_index=right_index,\n- by=by,\n- left_by=left_by,\n- right_by=right_by,\n- suffixes=suffixes,\n- how=\"asof\",\n- tolerance=tolerance,\n- allow_exact_matches=allow_exact_matches,\n- direction=direction,\n- )\n- return op.get_result()\n-\n-\n-# TODO: transformations??\n-# TODO: only copy DataFrames when modification necessary\n-class _MergeOperation:\n- \"\"\"\n- Perform a database (SQL) merge operation between two DataFrame or Series\n- objects using either columns as keys or their row indexes\n- \"\"\"\n-\n- _merge_type = \"merge\"\n-\n- def __init__(\n- self,\n- left: DataFrame | Series,\n- right: DataFrame | Series,\n- how: str = \"inner\",\n- on: IndexLabel | None = None,\n- left_on: IndexLabel | None = None,\n- right_on: IndexLabel | None = None,\n- axis: int = 1,\n- left_index: bool = False,\n- right_index: bool = False,\n- sort: bool = True,\n- suffixes: Suffixes = (\"_x\", \"_y\"),\n- copy: bool = True,\n- indicator: bool = False,\n- validate: str | None = None,\n- ) -> None:\n- _left = _validate_operand(left)\n- _right = _validate_operand(right)\n- self.left = self.orig_left = _left\n- self.right = self.orig_right = _right\n- self.how = how\n-\n- # bm_axis -> the axis on the BlockManager\n- self.bm_axis = axis\n- # axis --> the axis on the Series/DataFrame\n- self.axis = 1 - axis if self.left.ndim == 2 else 0\n-\n- self.on = com.maybe_make_list(on)\n- self.left_on = com.maybe_make_list(left_on)\n- self.right_on = com.maybe_make_list(right_on)\n-\n- self.copy = copy\n- self.suffixes = suffixes\n- self.sort = sort\n-\n- self.left_index = left_index\n- self.right_index = right_index\n-\n- self.indicator = indicator\n-\n- self.indicator_name: str | None\n- if isinstance(self.indicator, str):\n- self.indicator_name = self.indicator\n- elif isinstance(self.indicator, bool):\n- self.indicator_name = \"_merge\" if self.indicator else None\n- else:\n- raise ValueError(\n- \"indicator option can only accept boolean or string arguments\"\n- )\n-\n- if not is_bool(left_index):\n- raise ValueError(\n- f\"left_index parameter must be of type bool, not {type(left_index)}\"\n- )\n- if not is_bool(right_index):\n- raise ValueError(\n- f\"right_index parameter must be of type bool, not {type(right_index)}\"\n- )\n-\n- # warn user when merging between different levels\n- if _left.columns.nlevels != _right.columns.nlevels:\n- msg = (\n- \"merging between different levels is deprecated and will be removed \"\n- f\"in a future version. ({left.columns.nlevels} levels on the left, \"\n- f\"{right.columns.nlevels} on the right)\"\n- )\n- # stacklevel chosen to be correct when this is reached via pd.merge\n- # (and not DataFrame.join)\n- warnings.warn(msg, FutureWarning, stacklevel=find_stack_level())\n-\n- self._validate_specification()\n-\n- cross_col = None\n- if self.how == \"cross\":\n- (\n- self.left,\n- self.right,\n- self.how,\n- cross_col,\n- ) = self._create_cross_configuration(self.left, self.right)\n- self.left_on = self.right_on = [cross_col]\n- self._cross = cross_col\n-\n- # note this function has side effects\n- (\n- self.left_join_keys,\n- self.right_join_keys,\n- self.join_names,\n- ) = self._get_merge_keys()\n-\n- # validate the merge keys dtypes. We may need to coerce\n- # to avoid incompatible dtypes\n- self._maybe_coerce_merge_keys()\n-\n- # If argument passed to validate,\n- # check if columns specified as unique\n- # are in fact unique.\n- if validate is not None:\n- self._validate(validate)\n-\n- def get_result(self) -> DataFrame:\n- if self.indicator:\n- self.left, self.right = self._indicator_pre_merge(self.left, self.right)\n-\n- join_index, left_indexer, right_indexer = self._get_join_info()\n-\n- llabels, rlabels = _items_overlap_with_suffix(\n- self.left._info_axis, self.right._info_axis, self.suffixes\n- )\n-\n- lindexers = {1: left_indexer} if left_indexer is not None else {}\n- rindexers = {1: right_indexer} if right_indexer is not None else {}\n-\n- result_data = concatenate_managers(\n- [(self.left._mgr, lindexers), (self.right._mgr, rindexers)],\n- axes=[llabels.append(rlabels), join_index],\n- concat_axis=0,\n- copy=self.copy,\n- )\n-\n- typ = self.left._constructor\n- result = typ(result_data).__finalize__(self, method=self._merge_type)\n-\n- if self.indicator:\n- result = self._indicator_post_merge(result)\n-\n- self._maybe_add_join_keys(result, left_indexer, right_indexer)\n-\n- self._maybe_restore_index_levels(result)\n-\n- self._maybe_drop_cross_column(result, self._cross)\n-\n- return result.__finalize__(self, method=\"merge\")\n-\n- def _maybe_drop_cross_column(\n- self, result: DataFrame, cross_col: str | None\n- ) -> None:\n- if cross_col is not None:\n- del result[cross_col]\n-\n- def _indicator_pre_merge(\n- self, left: DataFrame, right: DataFrame\n- ) -> tuple[DataFrame, DataFrame]:\n-\n- columns = left.columns.union(right.columns)\n-\n- for i in [\"_left_indicator\", \"_right_indicator\"]:\n- if i in columns:\n- raise ValueError(\n- \"Cannot use `indicator=True` option when \"\n- f\"data contains a column named {i}\"\n- )\n- if self.indicator_name in columns:\n- raise ValueError(\n- \"Cannot use name of an existing column for indicator column\"\n- )\n-\n- left = left.copy()\n- right = right.copy()\n-\n- left[\"_left_indicator\"] = 1\n- left[\"_left_indicator\"] = left[\"_left_indicator\"].astype(\"int8\")\n-\n- right[\"_right_indicator\"] = 2\n- right[\"_right_indicator\"] = right[\"_right_indicator\"].astype(\"int8\")\n-\n- return left, right\n-\n- def _indicator_post_merge(self, result: DataFrame) -> DataFrame:\n-\n- result[\"_left_indicator\"] = result[\"_left_indicator\"].fillna(0)\n- result[\"_right_indicator\"] = result[\"_right_indicator\"].fillna(0)\n-\n- result[self.indicator_name] = Categorical(\n- (result[\"_left_indicator\"] + result[\"_right_indicator\"]),\n- categories=[1, 2, 3],\n- )\n- result[self.indicator_name] = result[self.indicator_name].cat.rename_categories(\n- [\"left_only\", \"right_only\", \"both\"]\n- )\n-\n- result = result.drop(labels=[\"_left_indicator\", \"_right_indicator\"], axis=1)\n- return result\n-\n- def _maybe_restore_index_levels(self, result: DataFrame) -> None:\n- \"\"\"\n- Restore index levels specified as `on` parameters\n-\n- Here we check for cases where `self.left_on` and `self.right_on` pairs\n- each reference an index level in their respective DataFrames. The\n- joined columns corresponding to these pairs are then restored to the\n- index of `result`.\n-\n- **Note:** This method has side effects. It modifies `result` in-place\n-\n- Parameters\n- ----------\n- result: DataFrame\n- merge result\n-\n- Returns\n- -------\n- None\n- \"\"\"\n- names_to_restore = []\n- for name, left_key, right_key in zip(\n- self.join_names, self.left_on, self.right_on\n- ):\n- if (\n- self.orig_left._is_level_reference(left_key)\n- and self.orig_right._is_level_reference(right_key)\n- and left_key == right_key\n- and name not in result.index.names\n- ):\n-\n- names_to_restore.append(name)\n-\n- if names_to_restore:\n- result.set_index(names_to_restore, inplace=True)\n-\n- def _maybe_add_join_keys(\n- self,\n- result: DataFrame,\n- left_indexer: np.ndarray | None,\n- right_indexer: np.ndarray | None,\n- ) -> None:\n-\n- left_has_missing = None\n- right_has_missing = None\n-\n- keys = zip(self.join_names, self.left_on, self.right_on)\n- for i, (name, lname, rname) in enumerate(keys):\n- if not _should_fill(lname, rname):\n- continue\n-\n- take_left, take_right = None, None\n-\n- if name in result:\n-\n- if left_indexer is not None and right_indexer is not None:\n- if name in self.left:\n-\n- if left_has_missing is None:\n- left_has_missing = (left_indexer == -1).any()\n-\n- if left_has_missing:\n- take_right = self.right_join_keys[i]\n-\n- if not is_dtype_equal(\n- result[name].dtype, self.left[name].dtype\n- ):\n- take_left = self.left[name]._values\n-\n- elif name in self.right:\n-\n- if right_has_missing is None:\n- right_has_missing = (right_indexer == -1).any()\n-\n- if right_has_missing:\n- take_left = self.left_join_keys[i]\n-\n- if not is_dtype_equal(\n- result[name].dtype, self.right[name].dtype\n- ):\n- take_right = self.right[name]._values\n-\n- elif left_indexer is not None and is_array_like(self.left_join_keys[i]):\n- take_left = self.left_join_keys[i]\n- take_right = self.right_join_keys[i]\n-\n- if take_left is not None or take_right is not None:\n-\n- if take_left is None:\n- lvals = result[name]._values\n- else:\n- # TODO: can we pin down take_left's type earlier?\n- take_left = extract_array(take_left, extract_numpy=True)\n- lfill = na_value_for_dtype(take_left.dtype)\n- lvals = algos.take_nd(take_left, left_indexer, fill_value=lfill)\n-\n- if take_right is None:\n- rvals = result[name]._values\n- else:\n- # TODO: can we pin down take_right's type earlier?\n- take_right = extract_array(take_right, extract_numpy=True)\n- rfill = na_value_for_dtype(take_right.dtype)\n- rvals = algos.take_nd(take_right, right_indexer, fill_value=rfill)\n-\n- # if we have an all missing left_indexer\n- # make sure to just use the right values or vice-versa\n- mask_left = left_indexer == -1\n- mask_right = right_indexer == -1\n- # error: Item \"bool\" of \"Union[Any, bool]\" has no attribute \"all\"\n- if mask_left.all(): # type: ignore[union-attr]\n- key_col = Index(rvals)\n- result_dtype = rvals.dtype\n- # error: Item \"bool\" of \"Union[Any, bool]\" has no attribute \"all\"\n- elif (\n- right_indexer is not None\n- and mask_right.all() # type: ignore[union-attr]\n- ):\n- key_col = Index(lvals)\n- result_dtype = lvals.dtype\n- else:\n- key_col = Index(lvals).where(~mask_left, rvals)\n- result_dtype = find_common_type([lvals.dtype, rvals.dtype])\n-\n- if result._is_label_reference(name):\n- result[name] = Series(\n- key_col, dtype=result_dtype, index=result.index\n- )\n- elif result._is_level_reference(name):\n- if isinstance(result.index, MultiIndex):\n- key_col.name = name\n- idx_list = [\n- result.index.get_level_values(level_name)\n- if level_name != name\n- else key_col\n- for level_name in result.index.names\n- ]\n-\n- result.set_index(idx_list, inplace=True)\n- else:\n- result.index = Index(key_col, name=name)\n- else:\n- result.insert(i, name or f\"key_{i}\", key_col)\n-\n- def _get_join_indexers(self) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:\n- \"\"\"return the join indexers\"\"\"\n- return get_join_indexers(\n- self.left_join_keys, self.right_join_keys, sort=self.sort, how=self.how\n- )\n-\n- def _get_join_info(\n- self,\n- ) -> tuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]:\n-\n- left_ax = self.left.axes[self.axis]\n- right_ax = self.right.axes[self.axis]\n-\n- if self.left_index and self.right_index and self.how != \"asof\":\n- join_index, left_indexer, right_indexer = left_ax.join(\n- right_ax, how=self.how, return_indexers=True, sort=self.sort\n- )\n-\n- elif self.right_index and self.how == \"left\":\n- join_index, left_indexer, right_indexer = _left_join_on_index(\n- left_ax, right_ax, self.left_join_keys, sort=self.sort\n- )\n-\n- elif self.left_index and self.how == \"right\":\n- join_index, right_indexer, left_indexer = _left_join_on_index(\n- right_ax, left_ax, self.right_join_keys, sort=self.sort\n- )\n- else:\n- (left_indexer, right_indexer) = self._get_join_indexers()\n-\n- if self.right_index:\n- if len(self.left) > 0:\n- join_index = self._create_join_index(\n- self.left.index,\n- self.right.index,\n- left_indexer,\n- how=\"right\",\n- )\n- else:\n- join_index = self.right.index.take(right_indexer)\n- elif self.left_index:\n- if self.how == \"asof\":\n- # GH#33463 asof should always behave like a left merge\n- join_index = self._create_join_index(\n- self.left.index,\n- self.right.index,\n- left_indexer,\n- how=\"left\",\n- )\n-\n- elif len(self.right) > 0:\n- join_index = self._create_join_index(\n- self.right.index,\n- self.left.index,\n- right_indexer,\n- how=\"left\",\n- )\n- else:\n- join_index = self.left.index.take(left_indexer)\n- else:\n- join_index = Index(np.arange(len(left_indexer)))\n-\n- if len(join_index) == 0:\n- join_index = join_index.astype(object)\n- return join_index, left_indexer, right_indexer\n-\n- def _create_join_index(\n- self,\n- index: Index,\n- other_index: Index,\n- indexer: npt.NDArray[np.intp],\n- how: str = \"left\",\n- ) -> Index:\n- \"\"\"\n- Create a join index by rearranging one index to match another\n-\n- Parameters\n- ----------\n- index : Index being rearranged\n- other_index : Index used to supply values not found in index\n- indexer : np.ndarray[np.intp] how to rearrange index\n- how : str\n- Replacement is only necessary if indexer based on other_index.\n-\n- Returns\n- -------\n- Index\n- \"\"\"\n- if self.how in (how, \"outer\") and not isinstance(other_index, MultiIndex):\n- # if final index requires values in other_index but not target\n- # index, indexer may hold missing (-1) values, causing Index.take\n- # to take the final value in target index. So, we set the last\n- # element to be the desired fill value. We do not use allow_fill\n- # and fill_value because it throws a ValueError on integer indices\n- mask = indexer == -1\n- if np.any(mask):\n- fill_value = na_value_for_dtype(index.dtype, compat=False)\n- index = index.append(Index([fill_value]))\n- return index.take(indexer)\n-\n- def _get_merge_keys(self):\n- \"\"\"\n- Note: has side effects (copy/delete key columns)\n-\n- Parameters\n- ----------\n- left\n- right\n- on\n-\n- Returns\n- -------\n- left_keys, right_keys\n- \"\"\"\n- left_keys = []\n- right_keys = []\n- # error: Need type annotation for 'join_names' (hint: \"join_names: List[<type>]\n- # = ...\")\n- join_names = [] # type: ignore[var-annotated]\n- right_drop = []\n- left_drop = []\n-\n- left, right = self.left, self.right\n-\n- is_lkey = lambda x: is_array_like(x) and len(x) == len(left)\n- is_rkey = lambda x: is_array_like(x) and len(x) == len(right)\n-\n- # Note that pd.merge_asof() has separate 'on' and 'by' parameters. A\n- # user could, for example, request 'left_index' and 'left_by'. In a\n- # regular pd.merge(), users cannot specify both 'left_index' and\n- # 'left_on'. (Instead, users have a MultiIndex). That means the\n- # self.left_on in this function is always empty in a pd.merge(), but\n- # a pd.merge_asof(left_index=True, left_by=...) will result in a\n- # self.left_on array with a None in the middle of it. This requires\n- # a work-around as designated in the code below.\n- # See _validate_specification() for where this happens.\n-\n- # ugh, spaghetti re #733\n- if _any(self.left_on) and _any(self.right_on):\n- for lk, rk in zip(self.left_on, self.right_on):\n- if is_lkey(lk):\n- left_keys.append(lk)\n- if is_rkey(rk):\n- right_keys.append(rk)\n- join_names.append(None) # what to do?\n- else:\n- if rk is not None:\n- right_keys.append(right._get_label_or_level_values(rk))\n- join_names.append(rk)\n- else:\n- # work-around for merge_asof(right_index=True)\n- right_keys.append(right.index)\n- join_names.append(right.index.name)\n- else:\n- if not is_rkey(rk):\n- if rk is not None:\n- right_keys.append(right._get_label_or_level_values(rk))\n- else:\n- # work-around for merge_asof(right_index=True)\n- right_keys.append(right.index)\n- if lk is not None and lk == rk:\n- # avoid key upcast in corner case (length-0)\n- if len(left) > 0:\n- right_drop.append(rk)\n- else:\n- left_drop.append(lk)\n- else:\n- right_keys.append(rk)\n- if lk is not None:\n- left_keys.append(left._get_label_or_level_values(lk))\n- join_names.append(lk)\n- else:\n- # work-around for merge_asof(left_index=True)\n- left_keys.append(left.index)\n- join_names.append(left.index.name)\n- elif _any(self.left_on):\n- for k in self.left_on:\n- if is_lkey(k):\n- left_keys.append(k)\n- join_names.append(None)\n- else:\n- left_keys.append(left._get_label_or_level_values(k))\n- join_names.append(k)\n- if isinstance(self.right.index, MultiIndex):\n- right_keys = [\n- lev._values.take(lev_codes)\n- for lev, lev_codes in zip(\n- self.right.index.levels, self.right.index.codes\n- )\n- ]\n- else:\n- right_keys = [self.right.index._values]\n- elif _any(self.right_on):\n- for k in self.right_on:\n- if is_rkey(k):\n- right_keys.append(k)\n- join_names.append(None)\n- else:\n- right_keys.append(right._get_label_or_level_values(k))\n- join_names.append(k)\n- if isinstance(self.left.index, MultiIndex):\n- left_keys = [\n- lev._values.take(lev_codes)\n- for lev, lev_codes in zip(\n- self.left.index.levels, self.left.index.codes\n- )\n- ]\n- else:\n- left_keys = [self.left.index._values]\n-\n- if left_drop:\n- self.left = self.left._drop_labels_or_levels(left_drop)\n-\n- if right_drop:\n- self.right = self.right._drop_labels_or_levels(right_drop)\n-\n- return left_keys, right_keys, join_names\n-\n- def _maybe_coerce_merge_keys(self) -> None:\n- # we have valid merges but we may have to further\n- # coerce these if they are originally incompatible types\n- #\n- # for example if these are categorical, but are not dtype_equal\n- # or if we have object and integer dtypes\n-\n- for lk, rk, name in zip(\n- self.left_join_keys, self.right_join_keys, self.join_names\n- ):\n- if (len(lk) and not len(rk)) or (not len(lk) and len(rk)):\n- continue\n-\n- lk_is_cat = is_categorical_dtype(lk.dtype)\n- rk_is_cat = is_categorical_dtype(rk.dtype)\n- lk_is_object = is_object_dtype(lk.dtype)\n- rk_is_object = is_object_dtype(rk.dtype)\n-\n- # if either left or right is a categorical\n- # then the must match exactly in categories & ordered\n- if lk_is_cat and rk_is_cat:\n- if lk._categories_match_up_to_permutation(rk):\n- continue\n-\n- elif lk_is_cat or rk_is_cat:\n- pass\n-\n- elif is_dtype_equal(lk.dtype, rk.dtype):\n- continue\n-\n- msg = (\n- f\"You are trying to merge on {lk.dtype} and \"\n- f\"{rk.dtype} columns. If you wish to proceed you should use pd.concat\"\n- )\n-\n- # if we are numeric, then allow differing\n- # kinds to proceed, eg. int64 and int8, int and float\n- # further if we are object, but we infer to\n- # the same, then proceed\n- if is_numeric_dtype(lk.dtype) and is_numeric_dtype(rk.dtype):\n- if lk.dtype.kind == rk.dtype.kind:\n- continue\n-\n- # check whether ints and floats\n- elif is_integer_dtype(rk.dtype) and is_float_dtype(lk.dtype):\n- # GH 47391 numpy > 1.24 will raise a RuntimeError for nan -> int\n- with np.errstate(invalid=\"ignore\"):\n- if not (lk == lk.astype(rk.dtype))[~np.isnan(lk)].all():\n- warnings.warn(\n- \"You are merging on int and float \"\n- \"columns where the float values \"\n- \"are not equal to their int representation.\",\n- UserWarning,\n- )\n- continue\n-\n- elif is_float_dtype(rk.dtype) and is_integer_dtype(lk.dtype):\n- # GH 47391 numpy > 1.24 will raise a RuntimeError for nan -> int\n- with np.errstate(invalid=\"ignore\"):\n- if not (rk == rk.astype(lk.dtype))[~np.isnan(rk)].all():\n- warnings.warn(\n- \"You are merging on int and float \"\n- \"columns where the float values \"\n- \"are not equal to their int representation.\",\n- UserWarning,\n- )\n- continue\n-\n- # let's infer and see if we are ok\n- elif lib.infer_dtype(lk, skipna=False) == lib.infer_dtype(\n- rk, skipna=False\n- ):\n- continue\n-\n- # Check if we are trying to merge on obviously\n- # incompatible dtypes GH 9780, GH 15800\n-\n- # bool values are coerced to object\n- elif (lk_is_object and is_bool_dtype(rk.dtype)) or (\n- is_bool_dtype(lk.dtype) and rk_is_object\n- ):\n- pass\n-\n- # object values are allowed to be merged\n- elif (lk_is_object and is_numeric_dtype(rk.dtype)) or (\n- is_numeric_dtype(lk.dtype) and rk_is_object\n- ):\n- inferred_left = lib.infer_dtype(lk, skipna=False)\n- inferred_right = lib.infer_dtype(rk, skipna=False)\n- bool_types = [\"integer\", \"mixed-integer\", \"boolean\", \"empty\"]\n- string_types = [\"string\", \"unicode\", \"mixed\", \"bytes\", \"empty\"]\n-\n- # inferred bool\n- if inferred_left in bool_types and inferred_right in bool_types:\n- pass\n-\n- # unless we are merging non-string-like with string-like\n- elif (\n- inferred_left in string_types and inferred_right not in string_types\n- ) or (\n- inferred_right in string_types and inferred_left not in string_types\n- ):\n- raise ValueError(msg)\n-\n- # datetimelikes must match exactly\n- elif needs_i8_conversion(lk.dtype) and not needs_i8_conversion(rk.dtype):\n- raise ValueError(msg)\n- elif not needs_i8_conversion(lk.dtype) and needs_i8_conversion(rk.dtype):\n- raise ValueError(msg)\n- elif is_datetime64tz_dtype(lk.dtype) and not is_datetime64tz_dtype(\n- rk.dtype\n- ):\n- raise ValueError(msg)\n- elif not is_datetime64tz_dtype(lk.dtype) and is_datetime64tz_dtype(\n- rk.dtype\n- ):\n- raise ValueError(msg)\n-\n- elif lk_is_object and rk_is_object:\n- continue\n-\n- # Houston, we have a problem!\n- # let's coerce to object if the dtypes aren't\n- # categorical, otherwise coerce to the category\n- # dtype. If we coerced categories to object,\n- # then we would lose type information on some\n- # columns, and end up trying to merge\n- # incompatible dtypes. See GH 16900.\n- if name in self.left.columns:\n- typ = lk.categories.dtype if lk_is_cat else object\n- self.left = self.left.copy()\n- self.left[name] = self.left[name].astype(typ)\n- if name in self.right.columns:\n- typ = rk.categories.dtype if rk_is_cat else object\n- self.right = self.right.copy()\n- self.right[name] = self.right[name].astype(typ)\n-\n- def _create_cross_configuration(\n- self, left: DataFrame, right: DataFrame\n- ) -> tuple[DataFrame, DataFrame, str, str]:\n- \"\"\"\n- Creates the configuration to dispatch the cross operation to inner join,\n- e.g. adding a join column and resetting parameters. Join column is added\n- to a new object, no inplace modification\n-\n- Parameters\n- ----------\n- left : DataFrame\n- right : DataFrame\n-\n- Returns\n- -------\n- a tuple (left, right, how, cross_col) representing the adjusted\n- DataFrames with cross_col, the merge operation set to inner and the column\n- to join over.\n- \"\"\"\n- cross_col = f\"_cross_{hashlib.md5().hexdigest()}\"\n- how = \"inner\"\n- return (\n- left.assign(**{cross_col: 1}),\n- right.assign(**{cross_col: 1}),\n- how,\n- cross_col,\n- )\n-\n- def _validate_specification(self) -> None:\n- if self.how == \"cross\":\n- if (\n- self.left_index\n- or self.right_index\n- or self.right_on is not None\n- or self.left_on is not None\n- or self.on is not None\n- ):\n- raise MergeError(\n- \"Can not pass on, right_on, left_on or set right_index=True or \"\n- \"left_index=True\"\n- )\n- return\n- # Hm, any way to make this logic less complicated??\n- elif self.on is None and self.left_on is None and self.right_on is None:\n-\n- if self.left_index and self.right_index:\n- self.left_on, self.right_on = (), ()\n- elif self.left_index:\n- raise MergeError(\"Must pass right_on or right_index=True\")\n- elif self.right_index:\n- raise MergeError(\"Must pass left_on or left_index=True\")\n- else:\n- # use the common columns\n- left_cols = self.left.columns\n- right_cols = self.right.columns\n- common_cols = left_cols.intersection(right_cols)\n- if len(common_cols) == 0:\n- raise MergeError(\n- \"No common columns to perform merge on. \"\n- f\"Merge options: left_on={self.left_on}, \"\n- f\"right_on={self.right_on}, \"\n- f\"left_index={self.left_index}, \"\n- f\"right_index={self.right_index}\"\n- )\n- if (\n- not left_cols.join(common_cols, how=\"inner\").is_unique\n- or not right_cols.join(common_cols, how=\"inner\").is_unique\n- ):\n- raise MergeError(f\"Data columns not unique: {repr(common_cols)}\")\n- self.left_on = self.right_on = common_cols\n- elif self.on is not None:\n- if self.left_on is not None or self.right_on is not None:\n- raise MergeError(\n- 'Can only pass argument \"on\" OR \"left_on\" '\n- 'and \"right_on\", not a combination of both.'\n- )\n- if self.left_index or self.right_index:\n- raise MergeError(\n- 'Can only pass argument \"on\" OR \"left_index\" '\n- 'and \"right_index\", not a combination of both.'\n- )\n- self.left_on = self.right_on = self.on\n- elif self.left_on is not None:\n- if self.left_index:\n- raise MergeError(\n- 'Can only pass argument \"left_on\" OR \"left_index\" not both.'\n- )\n- if not self.right_index and self.right_on is None:\n- raise MergeError('Must pass \"right_on\" OR \"right_index\".')\n- n = len(self.left_on)\n- if self.right_index:\n- if len(self.left_on) != self.right.index.nlevels:\n- raise ValueError(\n- \"len(left_on) must equal the number \"\n- 'of levels in the index of \"right\"'\n- )\n- self.right_on = [None] * n\n- elif self.right_on is not None:\n- if self.right_index:\n- raise MergeError(\n- 'Can only pass argument \"right_on\" OR \"right_index\" not both.'\n- )\n- if not self.left_index and self.left_on is None:\n- raise MergeError('Must pass \"left_on\" OR \"left_index\".')\n- n = len(self.right_on)\n- if self.left_index:\n- if len(self.right_on) != self.left.index.nlevels:\n- raise ValueError(\n- \"len(right_on) must equal the number \"\n- 'of levels in the index of \"left\"'\n- )\n- self.left_on = [None] * n\n- if self.how != \"cross\" and len(self.right_on) != len(self.left_on):\n- raise ValueError(\"len(right_on) must equal len(left_on)\")\n-\n- def _validate(self, validate: str) -> None:\n-\n- # Check uniqueness of each\n- if self.left_index:\n- left_unique = self.orig_left.index.is_unique\n- else:\n- left_unique = MultiIndex.from_arrays(self.left_join_keys).is_unique\n-\n- if self.right_index:\n- right_unique = self.orig_right.index.is_unique\n- else:\n- right_unique = MultiIndex.from_arrays(self.right_join_keys).is_unique\n-\n- # Check data integrity\n- if validate in [\"one_to_one\", \"1:1\"]:\n- if not left_unique and not right_unique:\n- raise MergeError(\n- \"Merge keys are not unique in either left \"\n- \"or right dataset; not a one-to-one merge\"\n- )\n- elif not left_unique:\n- raise MergeError(\n- \"Merge keys are not unique in left dataset; not a one-to-one merge\"\n- )\n- elif not right_unique:\n- raise MergeError(\n- \"Merge keys are not unique in right dataset; not a one-to-one merge\"\n- )\n-\n- elif validate in [\"one_to_many\", \"1:m\"]:\n- if not left_unique:\n- raise MergeError(\n- \"Merge keys are not unique in left dataset; not a one-to-many merge\"\n- )\n-\n- elif validate in [\"many_to_one\", \"m:1\"]:\n- if not right_unique:\n- raise MergeError(\n- \"Merge keys are not unique in right dataset; \"\n- \"not a many-to-one merge\"\n- )\n-\n- elif validate in [\"many_to_many\", \"m:m\"]:\n- pass\n-\n- else:\n- raise ValueError(\"Not a valid argument for validate\")\n-\n-\n-def get_join_indexers(\n- left_keys, right_keys, sort: bool = False, how: str = \"inner\", **kwargs\n-) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:\n- \"\"\"\n-\n- Parameters\n- ----------\n- left_keys : ndarray, Index, Series\n- right_keys : ndarray, Index, Series\n- sort : bool, default False\n- how : {'inner', 'outer', 'left', 'right'}, default 'inner'\n-\n- Returns\n- -------\n- np.ndarray[np.intp]\n- Indexer into the left_keys.\n- np.ndarray[np.intp]\n- Indexer into the right_keys.\n- \"\"\"\n- assert len(left_keys) == len(\n- right_keys\n- ), \"left_key and right_keys must be the same length\"\n-\n- # fast-path for empty left/right\n- left_n = len(left_keys[0])\n- right_n = len(right_keys[0])\n- if left_n == 0:\n- if how in [\"left\", \"inner\", \"cross\"]:\n- return _get_empty_indexer()\n- elif not sort and how in [\"right\", \"outer\"]:\n- return _get_no_sort_one_missing_indexer(right_n, True)\n- elif right_n == 0:\n- if how in [\"right\", \"inner\", \"cross\"]:\n- return _get_empty_indexer()\n- elif not sort and how in [\"left\", \"outer\"]:\n- return _get_no_sort_one_missing_indexer(left_n, False)\n-\n- # get left & right join labels and num. of levels at each location\n- mapped = (\n- _factorize_keys(left_keys[n], right_keys[n], sort=sort, how=how)\n- for n in range(len(left_keys))\n- )\n- zipped = zip(*mapped)\n- llab, rlab, shape = (list(x) for x in zipped)\n-\n- # get flat i8 keys from label lists\n- lkey, rkey = _get_join_keys(llab, rlab, shape, sort)\n-\n- # factorize keys to a dense i8 space\n- # `count` is the num. of unique keys\n- # set(lkey) | set(rkey) == range(count)\n-\n- lkey, rkey, count = _factorize_keys(lkey, rkey, sort=sort, how=how)\n- # preserve left frame order if how == 'left' and sort == False\n- kwargs = copy.copy(kwargs)\n- if how in (\"left\", \"right\"):\n- kwargs[\"sort\"] = sort\n- join_func = {\n- \"inner\": libjoin.inner_join,\n- \"left\": libjoin.left_outer_join,\n- \"right\": lambda x, y, count, **kwargs: libjoin.left_outer_join(\n- y, x, count, **kwargs\n- )[::-1],\n- \"outer\": libjoin.full_outer_join,\n- }[how]\n-\n- # error: Cannot call function of unknown type\n- return join_func(lkey, rkey, count, **kwargs) # type: ignore[operator]\n-\n-\n-def restore_dropped_levels_multijoin(\n- left: MultiIndex,\n- right: MultiIndex,\n- dropped_level_names,\n- join_index: Index,\n- lindexer: npt.NDArray[np.intp],\n- rindexer: npt.NDArray[np.intp],\n-) -> tuple[list[Index], npt.NDArray[np.intp], list[Hashable]]:\n- \"\"\"\n- *this is an internal non-public method*\n-\n- Returns the levels, labels and names of a multi-index to multi-index join.\n- Depending on the type of join, this method restores the appropriate\n- dropped levels of the joined multi-index.\n- The method relies on lidx, rindexer which hold the index positions of\n- left and right, where a join was feasible\n-\n- Parameters\n- ----------\n- left : MultiIndex\n- left index\n- right : MultiIndex\n- right index\n- dropped_level_names : str array\n- list of non-common level names\n- join_index : Index\n- the index of the join between the\n- common levels of left and right\n- lindexer : np.ndarray[np.intp]\n- left indexer\n- rindexer : np.ndarray[np.intp]\n- right indexer\n-\n- Returns\n- -------\n- levels : list of Index\n- levels of combined multiindexes\n- labels : np.ndarray[np.intp]\n- labels of combined multiindexes\n- names : List[Hashable]\n- names of combined multiindex levels\n-\n- \"\"\"\n-\n- def _convert_to_multiindex(index: Index) -> MultiIndex:\n- if isinstance(index, MultiIndex):\n- return index\n- else:\n- return MultiIndex.from_arrays([index._values], names=[index.name])\n-\n- # For multi-multi joins with one overlapping level,\n- # the returned index if of type Index\n- # Assure that join_index is of type MultiIndex\n- # so that dropped levels can be appended\n- join_index = _convert_to_multiindex(join_index)\n-\n- join_levels = join_index.levels\n- join_codes = join_index.codes\n- join_names = join_index.names\n-\n- # lindexer and rindexer hold the indexes where the join occurred\n- # for left and right respectively. If left/right is None then\n- # the join occurred on all indices of left/right\n- if lindexer is None:\n- lindexer = range(left.size)\n-\n- if rindexer is None:\n- rindexer = range(right.size)\n-\n- # Iterate through the levels that must be restored\n- for dropped_level_name in dropped_level_names:\n- if dropped_level_name in left.names:\n- idx = left\n- indexer = lindexer\n- else:\n- idx = right\n- indexer = rindexer\n-\n- # The index of the level name to be restored\n- name_idx = idx.names.index(dropped_level_name)\n-\n- restore_levels = idx.levels[name_idx]\n- # Inject -1 in the codes list where a join was not possible\n- # IOW indexer[i]=-1\n- codes = idx.codes[name_idx]\n- restore_codes = algos.take_nd(codes, indexer, fill_value=-1)\n-\n- join_levels = join_levels + [restore_levels]\n- join_codes = join_codes + [restore_codes]\n- join_names = join_names + [dropped_level_name]\n-\n- return join_levels, join_codes, join_names\n-\n-\n-class _OrderedMerge(_MergeOperation):\n- _merge_type = \"ordered_merge\"\n-\n- def __init__(\n- self,\n- left: DataFrame | Series,\n- right: DataFrame | Series,\n- on: IndexLabel | None = None,\n- left_on: IndexLabel | None = None,\n- right_on: IndexLabel | None = None,\n- left_index: bool = False,\n- right_index: bool = False,\n- axis: int = 1,\n- suffixes: Suffixes = (\"_x\", \"_y\"),\n- copy: bool = True,\n- fill_method: str | None = None,\n- how: str = \"outer\",\n- ) -> None:\n-\n- self.fill_method = fill_method\n- _MergeOperation.__init__(\n- self,\n- left,\n- right,\n- on=on,\n- left_on=left_on,\n- left_index=left_index,\n- right_index=right_index,\n- right_on=right_on,\n- axis=axis,\n- how=how,\n- suffixes=suffixes,\n- sort=True, # factorize sorts\n- )\n-\n- def get_result(self) -> DataFrame:\n- join_index, left_indexer, right_indexer = self._get_join_info()\n-\n- llabels, rlabels = _items_overlap_with_suffix(\n- self.left._info_axis, self.right._info_axis, self.suffixes\n- )\n-\n- left_join_indexer: np.ndarray | None\n- right_join_indexer: np.ndarray | None\n-\n- if self.fill_method == \"ffill\":\n- if left_indexer is None:\n- raise TypeError(\"left_indexer cannot be None\")\n- left_indexer, right_indexer = cast(np.ndarray, left_indexer), cast(\n- np.ndarray, right_indexer\n- )\n- left_join_indexer = libjoin.ffill_indexer(left_indexer)\n- right_join_indexer = libjoin.ffill_indexer(right_indexer)\n- else:\n- left_join_indexer = left_indexer\n- right_join_indexer = right_indexer\n-\n- lindexers = {1: left_join_indexer} if left_join_indexer is not None else {}\n- rindexers = {1: right_join_indexer} if right_join_indexer is not None else {}\n-\n- result_data = concatenate_managers(\n- [(self.left._mgr, lindexers), (self.right._mgr, rindexers)],\n- axes=[llabels.append(rlabels), join_index],\n- concat_axis=0,\n- copy=self.copy,\n- )\n-\n- typ = self.left._constructor\n- result = typ(result_data)\n-\n- self._maybe_add_join_keys(result, left_indexer, right_indexer)\n-\n- return result\n-\n-\n-def _asof_by_function(direction: str):\n- name = f\"asof_join_{direction}_on_X_by_Y\"\n- return getattr(libjoin, name, None)\n-\n-\n-_type_casters = {\n- \"int64_t\": ensure_int64,\n- \"double\": ensure_float64,\n- \"object\": ensure_object,\n-}\n-\n-\n-def _get_cython_type_upcast(dtype: DtypeObj) -> str:\n- \"\"\"Upcast a dtype to 'int64_t', 'double', or 'object'\"\"\"\n- if is_integer_dtype(dtype):\n- return \"int64_t\"\n- elif is_float_dtype(dtype):\n- return \"double\"\n- else:\n- return \"object\"\n-\n-\n-class _AsOfMerge(_OrderedMerge):\n- _merge_type = \"asof_merge\"\n-\n- def __init__(\n- self,\n- left: DataFrame | Series,\n- right: DataFrame | Series,\n- on: IndexLabel | None = None,\n- left_on: IndexLabel | None = None,\n- right_on: IndexLabel | None = None,\n- left_index: bool = False,\n- right_index: bool = False,\n- by=None,\n- left_by=None,\n- right_by=None,\n- axis: int = 1,\n- suffixes: Suffixes = (\"_x\", \"_y\"),\n- copy: bool = True,\n- fill_method: str | None = None,\n- how: str = \"asof\",\n- tolerance=None,\n- allow_exact_matches: bool = True,\n- direction: str = \"backward\",\n- ) -> None:\n-\n- self.by = by\n- self.left_by = left_by\n- self.right_by = right_by\n- self.tolerance = tolerance\n- self.allow_exact_matches = allow_exact_matches\n- self.direction = direction\n-\n- _OrderedMerge.__init__(\n- self,\n- left,\n- right,\n- on=on,\n- left_on=left_on,\n- right_on=right_on,\n- left_index=left_index,\n- right_index=right_index,\n- axis=axis,\n- how=how,\n- suffixes=suffixes,\n- fill_method=fill_method,\n- )\n-\n- def _validate_specification(self) -> None:\n- super()._validate_specification()\n-\n- # we only allow on to be a single item for on\n- if len(self.left_on) != 1 and not self.left_index:\n- raise MergeError(\"can only asof on a key for left\")\n-\n- if len(self.right_on) != 1 and not self.right_index:\n- raise MergeError(\"can only asof on a key for right\")\n-\n- if self.left_index and isinstance(self.left.index, MultiIndex):\n- raise MergeError(\"left can only have one index\")\n-\n- if self.right_index and isinstance(self.right.index, MultiIndex):\n- raise MergeError(\"right can only have one index\")\n-\n- # set 'by' columns\n- if self.by is not None:\n- if self.left_by is not None or self.right_by is not None:\n- raise MergeError(\"Can only pass by OR left_by and right_by\")\n- self.left_by = self.right_by = self.by\n- if self.left_by is None and self.right_by is not None:\n- raise MergeError(\"missing left_by\")\n- if self.left_by is not None and self.right_by is None:\n- raise MergeError(\"missing right_by\")\n-\n- # GH#29130 Check that merge keys do not have dtype object\n- if not self.left_index:\n- left_on = self.left_on[0]\n- if is_array_like(left_on):\n- lo_dtype = left_on.dtype\n- else:\n- lo_dtype = (\n- self.left[left_on].dtype\n- if left_on in self.left.columns\n- else self.left.index.get_level_values(left_on)\n- )\n- else:\n- lo_dtype = self.left.index.dtype\n-\n- if not self.right_index:\n- right_on = self.right_on[0]\n- if is_array_like(right_on):\n- ro_dtype = right_on.dtype\n- else:\n- ro_dtype = (\n- self.right[right_on].dtype\n- if right_on in self.right.columns\n- else self.right.index.get_level_values(right_on)\n- )\n- else:\n- ro_dtype = self.right.index.dtype\n-\n- if is_object_dtype(lo_dtype) or is_object_dtype(ro_dtype):\n- raise MergeError(\n- f\"Incompatible merge dtype, {repr(ro_dtype)} and \"\n- f\"{repr(lo_dtype)}, both sides must have numeric dtype\"\n- )\n-\n- # add 'by' to our key-list so we can have it in the\n- # output as a key\n- if self.left_by is not None:\n- if not is_list_like(self.left_by):\n- self.left_by = [self.left_by]\n- if not is_list_like(self.right_by):\n- self.right_by = [self.right_by]\n-\n- if len(self.left_by) != len(self.right_by):\n- raise MergeError(\"left_by and right_by must be same length\")\n-\n- self.left_on = self.left_by + list(self.left_on)\n- self.right_on = self.right_by + list(self.right_on)\n-\n- # check 'direction' is valid\n- if self.direction not in [\"backward\", \"forward\", \"nearest\"]:\n- raise MergeError(f\"direction invalid: {self.direction}\")\n-\n- def _get_merge_keys(self):\n-\n- # note this function has side effects\n- (left_join_keys, right_join_keys, join_names) = super()._get_merge_keys()\n-\n- # validate index types are the same\n- for i, (lk, rk) in enumerate(zip(left_join_keys, right_join_keys)):\n- if not is_dtype_equal(lk.dtype, rk.dtype):\n- if is_categorical_dtype(lk.dtype) and is_categorical_dtype(rk.dtype):\n- # The generic error message is confusing for categoricals.\n- #\n- # In this function, the join keys include both the original\n- # ones of the merge_asof() call, and also the keys passed\n- # to its by= argument. Unordered but equal categories\n- # are not supported for the former, but will fail\n- # later with a ValueError, so we don't *need* to check\n- # for them here.\n- msg = (\n- f\"incompatible merge keys [{i}] {repr(lk.dtype)} and \"\n- f\"{repr(rk.dtype)}, both sides category, but not equal ones\"\n- )\n- else:\n- msg = (\n- f\"incompatible merge keys [{i}] {repr(lk.dtype)} and \"\n- f\"{repr(rk.dtype)}, must be the same type\"\n- )\n- raise MergeError(msg)\n-\n- # validate tolerance; datetime.timedelta or Timedelta if we have a DTI\n- if self.tolerance is not None:\n-\n- if self.left_index:\n- lt = self.left.index\n- else:\n- lt = left_join_keys[-1]\n-\n- msg = (\n- f\"incompatible tolerance {self.tolerance}, must be compat \"\n- f\"with type {repr(lt.dtype)}\"\n- )\n-\n- if needs_i8_conversion(lt):\n- if not isinstance(self.tolerance, datetime.timedelta):\n- raise MergeError(msg)\n- if self.tolerance < Timedelta(0):\n- raise MergeError(\"tolerance must be positive\")\n-\n- elif is_integer_dtype(lt):\n- if not is_integer(self.tolerance):\n- raise MergeError(msg)\n- if self.tolerance < 0:\n- raise MergeError(\"tolerance must be positive\")\n-\n- elif is_float_dtype(lt):\n- if not is_number(self.tolerance):\n- raise MergeError(msg)\n- if self.tolerance < 0:\n- raise MergeError(\"tolerance must be positive\")\n-\n- else:\n- raise MergeError(\"key must be integer, timestamp or float\")\n-\n- # validate allow_exact_matches\n- if not is_bool(self.allow_exact_matches):\n- msg = (\n- \"allow_exact_matches must be boolean, \"\n- f\"passed {self.allow_exact_matches}\"\n- )\n- raise MergeError(msg)\n-\n- return left_join_keys, right_join_keys, join_names\n-\n- def _get_join_indexers(self) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:\n- \"\"\"return the join indexers\"\"\"\n-\n- def flip(xs) -> np.ndarray:\n- \"\"\"unlike np.transpose, this returns an array of tuples\"\"\"\n-\n- def injection(obj):\n- if not is_extension_array_dtype(obj):\n- # ndarray\n- return obj\n- obj = extract_array(obj)\n- if isinstance(obj, NDArrayBackedExtensionArray):\n- # fastpath for e.g. dt64tz, categorical\n- return obj._ndarray\n- # FIXME: returning obj._values_for_argsort() here doesn't\n- # break in any existing test cases, but i (@jbrockmendel)\n- # am pretty sure it should!\n- # e.g.\n- # arr = pd.array([0, pd.NA, 255], dtype=\"UInt8\")\n- # will have values_for_argsort (before GH#45434)\n- # np.array([0, 255, 255], dtype=np.uint8)\n- # and the non-injectivity should make a difference somehow\n- # shouldn't it?\n- return np.asarray(obj)\n-\n- xs = [injection(x) for x in xs]\n- labels = list(string.ascii_lowercase[: len(xs)])\n- dtypes = [x.dtype for x in xs]\n- labeled_dtypes = list(zip(labels, dtypes))\n- return np.array(list(zip(*xs)), labeled_dtypes)\n-\n- # values to compare\n- left_values = (\n- self.left.index._values if self.left_index else self.left_join_keys[-1]\n- )\n- right_values = (\n- self.right.index._values if self.right_index else self.right_join_keys[-1]\n- )\n- tolerance = self.tolerance\n-\n- # we require sortedness and non-null values in the join keys\n- if not Index(left_values).is_monotonic_increasing:\n- side = \"left\"\n- if isna(left_values).any():\n- raise ValueError(f\"Merge keys contain null values on {side} side\")\n- else:\n- raise ValueError(f\"{side} keys must be sorted\")\n-\n- if not Index(right_values).is_monotonic_increasing:\n- side = \"right\"\n- if isna(right_values).any():\n- raise ValueError(f\"Merge keys contain null values on {side} side\")\n- else:\n- raise ValueError(f\"{side} keys must be sorted\")\n-\n- # initial type conversion as needed\n- if needs_i8_conversion(left_values):\n- left_values = left_values.view(\"i8\")\n- right_values = right_values.view(\"i8\")\n- if tolerance is not None:\n- tolerance = Timedelta(tolerance)\n- tolerance = tolerance.value\n-\n- # a \"by\" parameter requires special handling\n- if self.left_by is not None:\n- # remove 'on' parameter from values if one existed\n- if self.left_index and self.right_index:\n- left_by_values = self.left_join_keys\n- right_by_values = self.right_join_keys\n- else:\n- left_by_values = self.left_join_keys[0:-1]\n- right_by_values = self.right_join_keys[0:-1]\n-\n- # get tuple representation of values if more than one\n- if len(left_by_values) == 1:\n- left_by_values = left_by_values[0]\n- right_by_values = right_by_values[0]\n- else:\n- # We get here with non-ndarrays in test_merge_by_col_tz_aware\n- # and test_merge_groupby_multiple_column_with_categorical_column\n- left_by_values = flip(left_by_values)\n- right_by_values = flip(right_by_values)\n-\n- # upcast 'by' parameter because HashTable is limited\n- by_type = _get_cython_type_upcast(left_by_values.dtype)\n- by_type_caster = _type_casters[by_type]\n- # error: Cannot call function of unknown type\n- left_by_values = by_type_caster(left_by_values) # type: ignore[operator]\n- # error: Cannot call function of unknown type\n- right_by_values = by_type_caster(right_by_values) # type: ignore[operator]\n-\n- # choose appropriate function by type\n- func = _asof_by_function(self.direction)\n- return func(\n- left_values,\n- right_values,\n- left_by_values,\n- right_by_values,\n- self.allow_exact_matches,\n- tolerance,\n- )\n- else:\n- # choose appropriate function by type\n- func = _asof_by_function(self.direction)\n- return func(\n- left_values,\n- right_values,\n- None,\n- None,\n- self.allow_exact_matches,\n- tolerance,\n- False,\n- )\n-\n-\n-def _get_multiindex_indexer(\n- join_keys, index: MultiIndex, sort: bool\n-) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:\n-\n- # left & right join labels and num. of levels at each location\n- mapped = (\n- _factorize_keys(index.levels[n], join_keys[n], sort=sort)\n- for n in range(index.nlevels)\n- )\n- zipped = zip(*mapped)\n- rcodes, lcodes, shape = (list(x) for x in zipped)\n- if sort:\n- rcodes = list(map(np.take, rcodes, index.codes))\n- else:\n- i8copy = lambda a: a.astype(\"i8\", subok=False, copy=True)\n- rcodes = list(map(i8copy, index.codes))\n-\n- # fix right labels if there were any nulls\n- for i in range(len(join_keys)):\n- mask = index.codes[i] == -1\n- if mask.any():\n- # check if there already was any nulls at this location\n- # if there was, it is factorized to `shape[i] - 1`\n- a = join_keys[i][lcodes[i] == shape[i] - 1]\n- if a.size == 0 or not a[0] != a[0]:\n- shape[i] += 1\n-\n- rcodes[i][mask] = shape[i] - 1\n-\n- # get flat i8 join keys\n- lkey, rkey = _get_join_keys(lcodes, rcodes, shape, sort)\n-\n- # factorize keys to a dense i8 space\n- lkey, rkey, count = _factorize_keys(lkey, rkey, sort=sort)\n-\n- return libjoin.left_outer_join(lkey, rkey, count, sort=sort)\n-\n-\n-def _get_single_indexer(\n- join_key, index: Index, sort: bool = False\n-) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:\n- left_key, right_key, count = _factorize_keys(join_key, index._values, sort=sort)\n-\n- return libjoin.left_outer_join(left_key, right_key, count, sort=sort)\n-\n-\n-def _get_empty_indexer() -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:\n- \"\"\"Return empty join indexers.\"\"\"\n- return (\n- np.array([], dtype=np.intp),\n- np.array([], dtype=np.intp),\n- )\n-\n-\n-def _get_no_sort_one_missing_indexer(\n- n: int, left_missing: bool\n-) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:\n- \"\"\"\n- Return join indexers where all of one side is selected without sorting\n- and none of the other side is selected.\n-\n- Parameters\n- ----------\n- n : int\n- Length of indexers to create.\n- left_missing : bool\n- If True, the left indexer will contain only -1's.\n- If False, the right indexer will contain only -1's.\n-\n- Returns\n- -------\n- np.ndarray[np.intp]\n- Left indexer\n- np.ndarray[np.intp]\n- Right indexer\n- \"\"\"\n- idx = np.arange(n, dtype=np.intp)\n- idx_missing = np.full(shape=n, fill_value=-1, dtype=np.intp)\n- if left_missing:\n- return idx_missing, idx\n- return idx, idx_missing\n-\n-\n-def _left_join_on_index(\n- left_ax: Index, right_ax: Index, join_keys, sort: bool = False\n-) -> tuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp]]:\n- if len(join_keys) > 1:\n- if not (\n- isinstance(right_ax, MultiIndex) and len(join_keys) == right_ax.nlevels\n- ):\n- raise AssertionError(\n- \"If more than one join key is given then \"\n- \"'right_ax' must be a MultiIndex and the \"\n- \"number of join keys must be the number of levels in right_ax\"\n- )\n-\n- left_indexer, right_indexer = _get_multiindex_indexer(\n- join_keys, right_ax, sort=sort\n- )\n- else:\n- jkey = join_keys[0]\n-\n- left_indexer, right_indexer = _get_single_indexer(jkey, right_ax, sort=sort)\n-\n- if sort or len(left_ax) != len(left_indexer):\n- # if asked to sort or there are 1-to-many matches\n- join_index = left_ax.take(left_indexer)\n- return join_index, left_indexer, right_indexer\n-\n- # left frame preserves order & length of its index\n- return left_ax, None, right_indexer\n-\n-\n-def _factorize_keys(\n- lk: ArrayLike, rk: ArrayLike, sort: bool = True, how: str = \"inner\"\n-) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp], int]:\n- \"\"\"\n- Encode left and right keys as enumerated types.\n-\n- This is used to get the join indexers to be used when merging DataFrames.\n-\n- Parameters\n- ----------\n- lk : array-like\n- Left key.\n- rk : array-like\n- Right key.\n- sort : bool, defaults to True\n- If True, the encoding is done such that the unique elements in the\n- keys are sorted.\n- how : {‘left’, ‘right’, ‘outer’, ‘inner’}, default ‘inner’\n- Type of merge.\n-\n- Returns\n- -------\n- np.ndarray[np.intp]\n- Left (resp. right if called with `key='right'`) labels, as enumerated type.\n- np.ndarray[np.intp]\n- Right (resp. left if called with `key='right'`) labels, as enumerated type.\n- int\n- Number of unique elements in union of left and right labels.\n-\n- See Also\n- --------\n- merge : Merge DataFrame or named Series objects\n- with a database-style join.\n- algorithms.factorize : Encode the object as an enumerated type\n- or categorical variable.\n-\n- Examples\n- --------\n- >>> lk = np.array([\"a\", \"c\", \"b\"])\n- >>> rk = np.array([\"a\", \"c\"])\n-\n- Here, the unique values are `'a', 'b', 'c'`. With the default\n- `sort=True`, the encoding will be `{0: 'a', 1: 'b', 2: 'c'}`:\n-\n- >>> pd.core.reshape.merge._factorize_keys(lk, rk)\n- (array([0, 2, 1]), array([0, 2]), 3)\n-\n- With the `sort=False`, the encoding will correspond to the order\n- in which the unique elements first appear: `{0: 'a', 1: 'c', 2: 'b'}`:\n-\n- >>> pd.core.reshape.merge._factorize_keys(lk, rk, sort=False)\n- (array([0, 1, 2]), array([0, 1]), 3)\n- \"\"\"\n- # Some pre-processing for non-ndarray lk / rk\n- lk = extract_array(lk, extract_numpy=True, extract_range=True)\n- rk = extract_array(rk, extract_numpy=True, extract_range=True)\n- # TODO: if either is a RangeIndex, we can likely factorize more efficiently?\n-\n- if is_datetime64tz_dtype(lk.dtype) and is_datetime64tz_dtype(rk.dtype):\n- # Extract the ndarray (UTC-localized) values\n- # Note: we dont need the dtypes to match, as these can still be compared\n- lk = cast(\"DatetimeArray\", lk)._ndarray\n- rk = cast(\"DatetimeArray\", rk)._ndarray\n-\n- elif (\n- is_categorical_dtype(lk.dtype)\n- and is_categorical_dtype(rk.dtype)\n- and is_dtype_equal(lk.dtype, rk.dtype)\n- ):\n- assert isinstance(lk, Categorical)\n- assert isinstance(rk, Categorical)\n- # Cast rk to encoding so we can compare codes with lk\n-\n- rk = lk._encode_with_my_categories(rk)\n-\n- lk = ensure_int64(lk.codes)\n- rk = ensure_int64(rk.codes)\n-\n- elif isinstance(lk, ExtensionArray) and is_dtype_equal(lk.dtype, rk.dtype):\n- lk, _ = lk._values_for_factorize()\n-\n- # error: Item \"ndarray\" of \"Union[Any, ndarray]\" has no attribute\n- # \"_values_for_factorize\"\n- rk, _ = rk._values_for_factorize() # type: ignore[union-attr]\n-\n- klass: type[libhashtable.Factorizer] | type[libhashtable.Int64Factorizer]\n- if is_integer_dtype(lk.dtype) and is_integer_dtype(rk.dtype):\n- # GH#23917 TODO: needs tests for case where lk is integer-dtype\n- # and rk is datetime-dtype\n- klass = libhashtable.Int64Factorizer\n- lk = ensure_int64(np.asarray(lk))\n- rk = ensure_int64(np.asarray(rk))\n-\n- elif needs_i8_conversion(lk.dtype) and is_dtype_equal(lk.dtype, rk.dtype):\n- # GH#23917 TODO: Needs tests for non-matching dtypes\n- klass = libhashtable.Int64Factorizer\n- lk = ensure_int64(np.asarray(lk, dtype=np.int64))\n- rk = ensure_int64(np.asarray(rk, dtype=np.int64))\n-\n- else:\n- klass = libhashtable.ObjectFactorizer\n- lk = ensure_object(lk)\n- rk = ensure_object(rk)\n-\n- rizer = klass(max(len(lk), len(rk)))\n-\n- # Argument 1 to \"factorize\" of \"ObjectFactorizer\" has incompatible type\n- # \"Union[ndarray[Any, dtype[signedinteger[_64Bit]]],\n- # ndarray[Any, dtype[object_]]]\"; expected \"ndarray[Any, dtype[object_]]\"\n- llab = rizer.factorize(lk) # type: ignore[arg-type]\n- # Argument 1 to \"factorize\" of \"ObjectFactorizer\" has incompatible type\n- # \"Union[ndarray[Any, dtype[signedinteger[_64Bit]]],\n- # ndarray[Any, dtype[object_]]]\"; expected \"ndarray[Any, dtype[object_]]\"\n- rlab = rizer.factorize(rk) # type: ignore[arg-type]\n- assert llab.dtype == np.dtype(np.intp), llab.dtype\n- assert rlab.dtype == np.dtype(np.intp), rlab.dtype\n-\n- count = rizer.get_count()\n-\n- if sort:\n- uniques = rizer.uniques.to_array()\n- llab, rlab = _sort_labels(uniques, llab, rlab)\n-\n- # NA group\n- lmask = llab == -1\n- lany = lmask.any()\n- rmask = rlab == -1\n- rany = rmask.any()\n-\n- if lany or rany:\n- if lany:\n- np.putmask(llab, lmask, count)\n- if rany:\n- np.putmask(rlab, rmask, count)\n- count += 1\n-\n- if how == \"right\":\n- return rlab, llab, count\n- return llab, rlab, count\n-\n-\n-def _sort_labels(\n- uniques: np.ndarray, left: npt.NDArray[np.intp], right: npt.NDArray[np.intp]\n-) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:\n-\n- llength = len(left)\n- labels = np.concatenate([left, right])\n-\n- _, new_labels = algos.safe_sort(uniques, labels, na_sentinel=-1)\n- new_left, new_right = new_labels[:llength], new_labels[llength:]\n-\n- return new_left, new_right\n-\n-\n-def _get_join_keys(llab, rlab, shape, sort: bool):\n-\n- # how many levels can be done without overflow\n- nlev = next(\n- lev\n- for lev in range(len(shape), 0, -1)\n- if not is_int64_overflow_possible(shape[:lev])\n- )\n-\n- # get keys for the first `nlev` levels\n- stride = np.prod(shape[1:nlev], dtype=\"i8\")\n- lkey = stride * llab[0].astype(\"i8\", subok=False, copy=False)\n- rkey = stride * rlab[0].astype(\"i8\", subok=False, copy=False)\n-\n- for i in range(1, nlev):\n- with np.errstate(divide=\"ignore\"):\n- stride //= shape[i]\n- lkey += llab[i] * stride\n- rkey += rlab[i] * stride\n-\n- if nlev == len(shape): # all done!\n- return lkey, rkey\n-\n- # densify current keys to avoid overflow\n- lkey, rkey, count = _factorize_keys(lkey, rkey, sort=sort)\n-\n- llab = [lkey] + llab[nlev:]\n- rlab = [rkey] + rlab[nlev:]\n- shape = [count] + shape[nlev:]\n-\n- return _get_join_keys(llab, rlab, shape, sort)\n-\n-\n-def _should_fill(lname, rname) -> bool:\n- if not isinstance(lname, str) or not isinstance(rname, str):\n- return True\n- return lname == rname\n-\n-\n-def _any(x) -> bool:\n- return x is not None and com.any_not_none(*x)\n-\n-\n-def _validate_operand(obj: DataFrame | Series) -> DataFrame:\n- if isinstance(obj, ABCDataFrame):\n- return obj\n- elif isinstance(obj, ABCSeries):\n- if obj.name is None:\n- raise ValueError(\"Cannot merge a Series without a name\")\n- else:\n- return obj.to_frame()\n- else:\n- raise TypeError(\n- f\"Can only merge Series or DataFrame objects, a {type(obj)} was passed\"\n- )\n-\n-\n-def _items_overlap_with_suffix(\n- left: Index, right: Index, suffixes: Suffixes\n-) -> tuple[Index, Index]:\n- \"\"\"\n- Suffixes type validation.\n-\n- If two indices overlap, add suffixes to overlapping entries.\n-\n- If corresponding suffix is empty, the entry is simply converted to string.\n-\n- \"\"\"\n- if not is_list_like(suffixes, allow_sets=False):\n- warnings.warn(\n- f\"Passing 'suffixes' as a {type(suffixes)}, is not supported and may give \"\n- \"unexpected results. Provide 'suffixes' as a tuple instead. In the \"\n- \"future a 'TypeError' will be raised.\",\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n-\n- to_rename = left.intersection(right)\n- if len(to_rename) == 0:\n- return left, right\n-\n- lsuffix, rsuffix = suffixes\n-\n- if not lsuffix and not rsuffix:\n- raise ValueError(f\"columns overlap but no suffix specified: {to_rename}\")\n-\n- def renamer(x, suffix):\n- \"\"\"\n- Rename the left and right indices.\n-\n- If there is overlap, and suffix is not None, add\n- suffix, otherwise, leave it as-is.\n-\n- Parameters\n- ----------\n- x : original column name\n- suffix : str or None\n-\n- Returns\n- -------\n- x : renamed column name\n- \"\"\"\n- if x in to_rename and suffix is not None:\n- return f\"{x}{suffix}\"\n- return x\n-\n- lrenamer = partial(renamer, suffix=lsuffix)\n- rrenamer = partial(renamer, suffix=rsuffix)\n-\n- llabels = left._transform_index(lrenamer)\n- rlabels = right._transform_index(rrenamer)\n-\n- dups = []\n- if not llabels.is_unique:\n- # Only warn when duplicates are caused because of suffixes, already duplicated\n- # columns in origin should not warn\n- dups = llabels[(llabels.duplicated()) & (~left.duplicated())].tolist()\n- if not rlabels.is_unique:\n- dups.extend(rlabels[(rlabels.duplicated()) & (~right.duplicated())].tolist())\n- if dups:\n- warnings.warn(\n- f\"Passing 'suffixes' which cause duplicate columns {set(dups)} in the \"\n- f\"result is deprecated and will raise a MergeError in a future version.\",\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n-\n- return llabels, rlabels\n+from pandas._core.reshape.merge import *\ndiff --git a/pandas/core/reshape/pivot.py b/pandas/core/reshape/pivot.py\nindex 8c861c199169b..7378c0d9ffe2e 100644\n--- a/pandas/core/reshape/pivot.py\n+++ b/pandas/core/reshape/pivot.py\n@@ -1,842 +1 @@\n-from __future__ import annotations\n-\n-from typing import (\n- TYPE_CHECKING,\n- Callable,\n- Hashable,\n- Sequence,\n- cast,\n-)\n-\n-import numpy as np\n-\n-from pandas._typing import (\n- AggFuncType,\n- AggFuncTypeBase,\n- AggFuncTypeDict,\n- IndexLabel,\n-)\n-from pandas.util._decorators import (\n- Appender,\n- Substitution,\n-)\n-\n-from pandas.core.dtypes.cast import maybe_downcast_to_dtype\n-from pandas.core.dtypes.common import (\n- is_integer_dtype,\n- is_list_like,\n- is_nested_list_like,\n- is_scalar,\n-)\n-from pandas.core.dtypes.generic import (\n- ABCDataFrame,\n- ABCSeries,\n-)\n-\n-import pandas.core.common as com\n-from pandas.core.frame import _shared_docs\n-from pandas.core.groupby import Grouper\n-from pandas.core.indexes.api import (\n- Index,\n- MultiIndex,\n- get_objs_combined_axis,\n-)\n-from pandas.core.reshape.concat import concat\n-from pandas.core.reshape.util import cartesian_product\n-from pandas.core.series import Series\n-\n-if TYPE_CHECKING:\n- from pandas import DataFrame\n-\n-\n-# Note: We need to make sure `frame` is imported before `pivot`, otherwise\n-# _shared_docs['pivot_table'] will not yet exist. TODO: Fix this dependency\n-@Substitution(\"\\ndata : DataFrame\")\n-@Appender(_shared_docs[\"pivot_table\"], indents=1)\n-def pivot_table(\n- data: DataFrame,\n- values=None,\n- index=None,\n- columns=None,\n- aggfunc: AggFuncType = \"mean\",\n- fill_value=None,\n- margins: bool = False,\n- dropna: bool = True,\n- margins_name: str = \"All\",\n- observed: bool = False,\n- sort: bool = True,\n-) -> DataFrame:\n- index = _convert_by(index)\n- columns = _convert_by(columns)\n-\n- if isinstance(aggfunc, list):\n- pieces: list[DataFrame] = []\n- keys = []\n- for func in aggfunc:\n- _table = __internal_pivot_table(\n- data,\n- values=values,\n- index=index,\n- columns=columns,\n- fill_value=fill_value,\n- aggfunc=func,\n- margins=margins,\n- dropna=dropna,\n- margins_name=margins_name,\n- observed=observed,\n- sort=sort,\n- )\n- pieces.append(_table)\n- keys.append(getattr(func, \"__name__\", func))\n-\n- table = concat(pieces, keys=keys, axis=1)\n- return table.__finalize__(data, method=\"pivot_table\")\n-\n- table = __internal_pivot_table(\n- data,\n- values,\n- index,\n- columns,\n- aggfunc,\n- fill_value,\n- margins,\n- dropna,\n- margins_name,\n- observed,\n- sort,\n- )\n- return table.__finalize__(data, method=\"pivot_table\")\n-\n-\n-def __internal_pivot_table(\n- data: DataFrame,\n- values,\n- index,\n- columns,\n- aggfunc: AggFuncTypeBase | AggFuncTypeDict,\n- fill_value,\n- margins: bool,\n- dropna: bool,\n- margins_name: str,\n- observed: bool,\n- sort: bool,\n-) -> DataFrame:\n- \"\"\"\n- Helper of :func:`pandas.pivot_table` for any non-list ``aggfunc``.\n- \"\"\"\n- keys = index + columns\n-\n- values_passed = values is not None\n- if values_passed:\n- if is_list_like(values):\n- values_multi = True\n- values = list(values)\n- else:\n- values_multi = False\n- values = [values]\n-\n- # GH14938 Make sure value labels are in data\n- for i in values:\n- if i not in data:\n- raise KeyError(i)\n-\n- to_filter = []\n- for x in keys + values:\n- if isinstance(x, Grouper):\n- x = x.key\n- try:\n- if x in data:\n- to_filter.append(x)\n- except TypeError:\n- pass\n- if len(to_filter) < len(data.columns):\n- data = data[to_filter]\n-\n- else:\n- values = data.columns\n- for key in keys:\n- try:\n- values = values.drop(key)\n- except (TypeError, ValueError, KeyError):\n- pass\n- values = list(values)\n-\n- grouped = data.groupby(keys, observed=observed, sort=sort)\n- agged = grouped.agg(aggfunc)\n- if dropna and isinstance(agged, ABCDataFrame) and len(agged.columns):\n- agged = agged.dropna(how=\"all\")\n-\n- # gh-21133\n- # we want to down cast if\n- # the original values are ints\n- # as we grouped with a NaN value\n- # and then dropped, coercing to floats\n- for v in values:\n- if (\n- v in data\n- and is_integer_dtype(data[v])\n- and v in agged\n- and not is_integer_dtype(agged[v])\n- ):\n- if not isinstance(agged[v], ABCDataFrame):\n- # exclude DataFrame case bc maybe_downcast_to_dtype expects\n- # ArrayLike\n- # e.g. test_pivot_table_multiindex_columns_doctest_case\n- # agged.columns is a MultiIndex and 'v' is indexing only\n- # on its first level.\n- agged[v] = maybe_downcast_to_dtype(agged[v], data[v].dtype)\n-\n- table = agged\n-\n- # GH17038, this check should only happen if index is defined (not None)\n- if table.index.nlevels > 1 and index:\n- # Related GH #17123\n- # If index_names are integers, determine whether the integers refer\n- # to the level position or name.\n- index_names = agged.index.names[: len(index)]\n- to_unstack = []\n- for i in range(len(index), len(keys)):\n- name = agged.index.names[i]\n- if name is None or name in index_names:\n- to_unstack.append(i)\n- else:\n- to_unstack.append(name)\n- table = agged.unstack(to_unstack)\n-\n- if not dropna:\n- if isinstance(table.index, MultiIndex):\n- m = MultiIndex.from_arrays(\n- cartesian_product(table.index.levels), names=table.index.names\n- )\n- table = table.reindex(m, axis=0)\n-\n- if isinstance(table.columns, MultiIndex):\n- m = MultiIndex.from_arrays(\n- cartesian_product(table.columns.levels), names=table.columns.names\n- )\n- table = table.reindex(m, axis=1)\n-\n- if sort is True and isinstance(table, ABCDataFrame):\n- table = table.sort_index(axis=1)\n-\n- if fill_value is not None:\n- table = table.fillna(fill_value, downcast=\"infer\")\n-\n- if margins:\n- if dropna:\n- data = data[data.notna().all(axis=1)]\n- table = _add_margins(\n- table,\n- data,\n- values,\n- rows=index,\n- cols=columns,\n- aggfunc=aggfunc,\n- observed=dropna,\n- margins_name=margins_name,\n- fill_value=fill_value,\n- )\n-\n- # discard the top level\n- if values_passed and not values_multi and table.columns.nlevels > 1:\n- table = table.droplevel(0, axis=1)\n- if len(index) == 0 and len(columns) > 0:\n- table = table.T\n-\n- # GH 15193 Make sure empty columns are removed if dropna=True\n- if isinstance(table, ABCDataFrame) and dropna:\n- table = table.dropna(how=\"all\", axis=1)\n-\n- return table\n-\n-\n-def _add_margins(\n- table: DataFrame | Series,\n- data: DataFrame,\n- values,\n- rows,\n- cols,\n- aggfunc,\n- observed=None,\n- margins_name: str = \"All\",\n- fill_value=None,\n-):\n- if not isinstance(margins_name, str):\n- raise ValueError(\"margins_name argument must be a string\")\n-\n- msg = f'Conflicting name \"{margins_name}\" in margins'\n- for level in table.index.names:\n- if margins_name in table.index.get_level_values(level):\n- raise ValueError(msg)\n-\n- grand_margin = _compute_grand_margin(data, values, aggfunc, margins_name)\n-\n- if table.ndim == 2:\n- # i.e. DataFrame\n- for level in table.columns.names[1:]:\n- if margins_name in table.columns.get_level_values(level):\n- raise ValueError(msg)\n-\n- key: str | tuple[str, ...]\n- if len(rows) > 1:\n- key = (margins_name,) + (\"\",) * (len(rows) - 1)\n- else:\n- key = margins_name\n-\n- if not values and isinstance(table, ABCSeries):\n- # If there are no values and the table is a series, then there is only\n- # one column in the data. Compute grand margin and return it.\n- return table._append(Series({key: grand_margin[margins_name]}))\n-\n- elif values:\n- marginal_result_set = _generate_marginal_results(\n- table, data, values, rows, cols, aggfunc, observed, margins_name\n- )\n- if not isinstance(marginal_result_set, tuple):\n- return marginal_result_set\n- result, margin_keys, row_margin = marginal_result_set\n- else:\n- # no values, and table is a DataFrame\n- assert isinstance(table, ABCDataFrame)\n- marginal_result_set = _generate_marginal_results_without_values(\n- table, data, rows, cols, aggfunc, observed, margins_name\n- )\n- if not isinstance(marginal_result_set, tuple):\n- return marginal_result_set\n- result, margin_keys, row_margin = marginal_result_set\n-\n- row_margin = row_margin.reindex(result.columns, fill_value=fill_value)\n- # populate grand margin\n- for k in margin_keys:\n- if isinstance(k, str):\n- row_margin[k] = grand_margin[k]\n- else:\n- row_margin[k] = grand_margin[k[0]]\n-\n- from pandas import DataFrame\n-\n- margin_dummy = DataFrame(row_margin, columns=[key]).T\n-\n- row_names = result.index.names\n- # check the result column and leave floats\n- for dtype in set(result.dtypes):\n- cols = result.select_dtypes([dtype]).columns\n- margin_dummy[cols] = margin_dummy[cols].apply(\n- maybe_downcast_to_dtype, args=(dtype,)\n- )\n- result = result._append(margin_dummy)\n- result.index.names = row_names\n-\n- return result\n-\n-\n-def _compute_grand_margin(data: DataFrame, values, aggfunc, margins_name: str = \"All\"):\n-\n- if values:\n- grand_margin = {}\n- for k, v in data[values].items():\n- try:\n- if isinstance(aggfunc, str):\n- grand_margin[k] = getattr(v, aggfunc)()\n- elif isinstance(aggfunc, dict):\n- if isinstance(aggfunc[k], str):\n- grand_margin[k] = getattr(v, aggfunc[k])()\n- else:\n- grand_margin[k] = aggfunc[k](v)\n- else:\n- grand_margin[k] = aggfunc(v)\n- except TypeError:\n- pass\n- return grand_margin\n- else:\n- return {margins_name: aggfunc(data.index)}\n-\n-\n-def _generate_marginal_results(\n- table, data, values, rows, cols, aggfunc, observed, margins_name: str = \"All\"\n-):\n- if len(cols) > 0:\n- # need to \"interleave\" the margins\n- table_pieces = []\n- margin_keys = []\n-\n- def _all_key(key):\n- return (key, margins_name) + (\"\",) * (len(cols) - 1)\n-\n- if len(rows) > 0:\n- margin = data[rows + values].groupby(rows, observed=observed).agg(aggfunc)\n- cat_axis = 1\n-\n- for key, piece in table.groupby(level=0, axis=cat_axis, observed=observed):\n- all_key = _all_key(key)\n-\n- # we are going to mutate this, so need to copy!\n- piece = piece.copy()\n- piece[all_key] = margin[key]\n-\n- table_pieces.append(piece)\n- margin_keys.append(all_key)\n- else:\n- from pandas import DataFrame\n-\n- cat_axis = 0\n- for key, piece in table.groupby(level=0, axis=cat_axis, observed=observed):\n- if len(cols) > 1:\n- all_key = _all_key(key)\n- else:\n- all_key = margins_name\n- table_pieces.append(piece)\n- # GH31016 this is to calculate margin for each group, and assign\n- # corresponded key as index\n- transformed_piece = DataFrame(piece.apply(aggfunc)).T\n- transformed_piece.index = Index([all_key], name=piece.index.name)\n-\n- # append piece for margin into table_piece\n- table_pieces.append(transformed_piece)\n- margin_keys.append(all_key)\n-\n- result = concat(table_pieces, axis=cat_axis)\n-\n- if len(rows) == 0:\n- return result\n- else:\n- result = table\n- margin_keys = table.columns\n-\n- if len(cols) > 0:\n- row_margin = data[cols + values].groupby(cols, observed=observed).agg(aggfunc)\n- row_margin = row_margin.stack()\n-\n- # slight hack\n- new_order = [len(cols)] + list(range(len(cols)))\n- row_margin.index = row_margin.index.reorder_levels(new_order)\n- else:\n- row_margin = Series(np.nan, index=result.columns)\n-\n- return result, margin_keys, row_margin\n-\n-\n-def _generate_marginal_results_without_values(\n- table: DataFrame, data, rows, cols, aggfunc, observed, margins_name: str = \"All\"\n-):\n- if len(cols) > 0:\n- # need to \"interleave\" the margins\n- margin_keys: list | Index = []\n-\n- def _all_key():\n- if len(cols) == 1:\n- return margins_name\n- return (margins_name,) + (\"\",) * (len(cols) - 1)\n-\n- if len(rows) > 0:\n- margin = data[rows].groupby(rows, observed=observed).apply(aggfunc)\n- all_key = _all_key()\n- table[all_key] = margin\n- result = table\n- margin_keys.append(all_key)\n-\n- else:\n- margin = data.groupby(level=0, axis=0, observed=observed).apply(aggfunc)\n- all_key = _all_key()\n- table[all_key] = margin\n- result = table\n- margin_keys.append(all_key)\n- return result\n- else:\n- result = table\n- margin_keys = table.columns\n-\n- if len(cols):\n- row_margin = data[cols].groupby(cols, observed=observed).apply(aggfunc)\n- else:\n- row_margin = Series(np.nan, index=result.columns)\n-\n- return result, margin_keys, row_margin\n-\n-\n-def _convert_by(by):\n- if by is None:\n- by = []\n- elif (\n- is_scalar(by)\n- or isinstance(by, (np.ndarray, Index, ABCSeries, Grouper))\n- or callable(by)\n- ):\n- by = [by]\n- else:\n- by = list(by)\n- return by\n-\n-\n-@Substitution(\"\\ndata : DataFrame\")\n-@Appender(_shared_docs[\"pivot\"], indents=1)\n-def pivot(\n- data: DataFrame,\n- index: IndexLabel | None = None,\n- columns: IndexLabel | None = None,\n- values: IndexLabel | None = None,\n-) -> DataFrame:\n- if columns is None:\n- raise TypeError(\"pivot() missing 1 required argument: 'columns'\")\n-\n- columns_listlike = com.convert_to_list_like(columns)\n-\n- if values is None:\n- if index is not None:\n- cols = com.convert_to_list_like(index)\n- else:\n- cols = []\n-\n- append = index is None\n- # error: Unsupported operand types for + (\"List[Any]\" and \"ExtensionArray\")\n- # error: Unsupported left operand type for + (\"ExtensionArray\")\n- indexed = data.set_index(\n- cols + columns_listlike, append=append # type: ignore[operator]\n- )\n- else:\n- if index is None:\n- if isinstance(data.index, MultiIndex):\n- # GH 23955\n- index_list = [\n- data.index.get_level_values(i) for i in range(data.index.nlevels)\n- ]\n- else:\n- index_list = [Series(data.index, name=data.index.name)]\n- else:\n- index_list = [data[idx] for idx in com.convert_to_list_like(index)]\n-\n- data_columns = [data[col] for col in columns_listlike]\n- index_list.extend(data_columns)\n- multiindex = MultiIndex.from_arrays(index_list)\n-\n- if is_list_like(values) and not isinstance(values, tuple):\n- # Exclude tuple because it is seen as a single column name\n- values = cast(Sequence[Hashable], values)\n- indexed = data._constructor(\n- data[values]._values, index=multiindex, columns=values\n- )\n- else:\n- indexed = data._constructor_sliced(data[values]._values, index=multiindex)\n- return indexed.unstack(columns_listlike)\n-\n-\n-def crosstab(\n- index,\n- columns,\n- values=None,\n- rownames=None,\n- colnames=None,\n- aggfunc=None,\n- margins: bool = False,\n- margins_name: str = \"All\",\n- dropna: bool = True,\n- normalize=False,\n-) -> DataFrame:\n- \"\"\"\n- Compute a simple cross tabulation of two (or more) factors. By default\n- computes a frequency table of the factors unless an array of values and an\n- aggregation function are passed.\n-\n- Parameters\n- ----------\n- index : array-like, Series, or list of arrays/Series\n- Values to group by in the rows.\n- columns : array-like, Series, or list of arrays/Series\n- Values to group by in the columns.\n- values : array-like, optional\n- Array of values to aggregate according to the factors.\n- Requires `aggfunc` be specified.\n- rownames : sequence, default None\n- If passed, must match number of row arrays passed.\n- colnames : sequence, default None\n- If passed, must match number of column arrays passed.\n- aggfunc : function, optional\n- If specified, requires `values` be specified as well.\n- margins : bool, default False\n- Add row/column margins (subtotals).\n- margins_name : str, default 'All'\n- Name of the row/column that will contain the totals\n- when margins is True.\n- dropna : bool, default True\n- Do not include columns whose entries are all NaN.\n- normalize : bool, {'all', 'index', 'columns'}, or {0,1}, default False\n- Normalize by dividing all values by the sum of values.\n-\n- - If passed 'all' or `True`, will normalize over all values.\n- - If passed 'index' will normalize over each row.\n- - If passed 'columns' will normalize over each column.\n- - If margins is `True`, will also normalize margin values.\n-\n- Returns\n- -------\n- DataFrame\n- Cross tabulation of the data.\n-\n- See Also\n- --------\n- DataFrame.pivot : Reshape data based on column values.\n- pivot_table : Create a pivot table as a DataFrame.\n-\n- Notes\n- -----\n- Any Series passed will have their name attributes used unless row or column\n- names for the cross-tabulation are specified.\n-\n- Any input passed containing Categorical data will have **all** of its\n- categories included in the cross-tabulation, even if the actual data does\n- not contain any instances of a particular category.\n-\n- In the event that there aren't overlapping indexes an empty DataFrame will\n- be returned.\n-\n- Reference :ref:`the user guide <reshaping.crosstabulations>` for more examples.\n-\n- Examples\n- --------\n- >>> a = np.array([\"foo\", \"foo\", \"foo\", \"foo\", \"bar\", \"bar\",\n- ... \"bar\", \"bar\", \"foo\", \"foo\", \"foo\"], dtype=object)\n- >>> b = np.array([\"one\", \"one\", \"one\", \"two\", \"one\", \"one\",\n- ... \"one\", \"two\", \"two\", \"two\", \"one\"], dtype=object)\n- >>> c = np.array([\"dull\", \"dull\", \"shiny\", \"dull\", \"dull\", \"shiny\",\n- ... \"shiny\", \"dull\", \"shiny\", \"shiny\", \"shiny\"],\n- ... dtype=object)\n- >>> pd.crosstab(a, [b, c], rownames=['a'], colnames=['b', 'c'])\n- b one two\n- c dull shiny dull shiny\n- a\n- bar 1 2 1 0\n- foo 2 2 1 2\n-\n- Here 'c' and 'f' are not represented in the data and will not be\n- shown in the output because dropna is True by default. Set\n- dropna=False to preserve categories with no data.\n-\n- >>> foo = pd.Categorical(['a', 'b'], categories=['a', 'b', 'c'])\n- >>> bar = pd.Categorical(['d', 'e'], categories=['d', 'e', 'f'])\n- >>> pd.crosstab(foo, bar)\n- col_0 d e\n- row_0\n- a 1 0\n- b 0 1\n- >>> pd.crosstab(foo, bar, dropna=False)\n- col_0 d e f\n- row_0\n- a 1 0 0\n- b 0 1 0\n- c 0 0 0\n- \"\"\"\n- if values is None and aggfunc is not None:\n- raise ValueError(\"aggfunc cannot be used without values.\")\n-\n- if values is not None and aggfunc is None:\n- raise ValueError(\"values cannot be used without an aggfunc.\")\n-\n- if not is_nested_list_like(index):\n- index = [index]\n- if not is_nested_list_like(columns):\n- columns = [columns]\n-\n- common_idx = None\n- pass_objs = [x for x in index + columns if isinstance(x, (ABCSeries, ABCDataFrame))]\n- if pass_objs:\n- common_idx = get_objs_combined_axis(pass_objs, intersect=True, sort=False)\n-\n- rownames = _get_names(index, rownames, prefix=\"row\")\n- colnames = _get_names(columns, colnames, prefix=\"col\")\n-\n- # duplicate names mapped to unique names for pivot op\n- (\n- rownames_mapper,\n- unique_rownames,\n- colnames_mapper,\n- unique_colnames,\n- ) = _build_names_mapper(rownames, colnames)\n-\n- from pandas import DataFrame\n-\n- data = {\n- **dict(zip(unique_rownames, index)),\n- **dict(zip(unique_colnames, columns)),\n- }\n- df = DataFrame(data, index=common_idx)\n-\n- if values is None:\n- df[\"__dummy__\"] = 0\n- kwargs = {\"aggfunc\": len, \"fill_value\": 0}\n- else:\n- df[\"__dummy__\"] = values\n- kwargs = {\"aggfunc\": aggfunc}\n-\n- table = df.pivot_table(\n- \"__dummy__\",\n- index=unique_rownames,\n- columns=unique_colnames,\n- margins=margins,\n- margins_name=margins_name,\n- dropna=dropna,\n- **kwargs,\n- )\n-\n- # Post-process\n- if normalize is not False:\n- table = _normalize(\n- table, normalize=normalize, margins=margins, margins_name=margins_name\n- )\n-\n- table = table.rename_axis(index=rownames_mapper, axis=0)\n- table = table.rename_axis(columns=colnames_mapper, axis=1)\n-\n- return table\n-\n-\n-def _normalize(\n- table: DataFrame, normalize, margins: bool, margins_name=\"All\"\n-) -> DataFrame:\n-\n- if not isinstance(normalize, (bool, str)):\n- axis_subs = {0: \"index\", 1: \"columns\"}\n- try:\n- normalize = axis_subs[normalize]\n- except KeyError as err:\n- raise ValueError(\"Not a valid normalize argument\") from err\n-\n- if margins is False:\n-\n- # Actual Normalizations\n- normalizers: dict[bool | str, Callable] = {\n- \"all\": lambda x: x / x.sum(axis=1).sum(axis=0),\n- \"columns\": lambda x: x / x.sum(),\n- \"index\": lambda x: x.div(x.sum(axis=1), axis=0),\n- }\n-\n- normalizers[True] = normalizers[\"all\"]\n-\n- try:\n- f = normalizers[normalize]\n- except KeyError as err:\n- raise ValueError(\"Not a valid normalize argument\") from err\n-\n- table = f(table)\n- table = table.fillna(0)\n-\n- elif margins is True:\n- # keep index and column of pivoted table\n- table_index = table.index\n- table_columns = table.columns\n- last_ind_or_col = table.iloc[-1, :].name\n-\n- # check if margin name is not in (for MI cases) and not equal to last\n- # index/column and save the column and index margin\n- if (margins_name not in last_ind_or_col) & (margins_name != last_ind_or_col):\n- raise ValueError(f\"{margins_name} not in pivoted DataFrame\")\n- column_margin = table.iloc[:-1, -1]\n- index_margin = table.iloc[-1, :-1]\n-\n- # keep the core table\n- table = table.iloc[:-1, :-1]\n-\n- # Normalize core\n- table = _normalize(table, normalize=normalize, margins=False)\n-\n- # Fix Margins\n- if normalize == \"columns\":\n- column_margin = column_margin / column_margin.sum()\n- table = concat([table, column_margin], axis=1)\n- table = table.fillna(0)\n- table.columns = table_columns\n-\n- elif normalize == \"index\":\n- index_margin = index_margin / index_margin.sum()\n- table = table._append(index_margin)\n- table = table.fillna(0)\n- table.index = table_index\n-\n- elif normalize == \"all\" or normalize is True:\n- column_margin = column_margin / column_margin.sum()\n- index_margin = index_margin / index_margin.sum()\n- index_margin.loc[margins_name] = 1\n- table = concat([table, column_margin], axis=1)\n- table = table._append(index_margin)\n-\n- table = table.fillna(0)\n- table.index = table_index\n- table.columns = table_columns\n-\n- else:\n- raise ValueError(\"Not a valid normalize argument\")\n-\n- else:\n- raise ValueError(\"Not a valid margins argument\")\n-\n- return table\n-\n-\n-def _get_names(arrs, names, prefix: str = \"row\"):\n- if names is None:\n- names = []\n- for i, arr in enumerate(arrs):\n- if isinstance(arr, ABCSeries) and arr.name is not None:\n- names.append(arr.name)\n- else:\n- names.append(f\"{prefix}_{i}\")\n- else:\n- if len(names) != len(arrs):\n- raise AssertionError(\"arrays and names must have the same length\")\n- if not isinstance(names, list):\n- names = list(names)\n-\n- return names\n-\n-\n-def _build_names_mapper(\n- rownames: list[str], colnames: list[str]\n-) -> tuple[dict[str, str], list[str], dict[str, str], list[str]]:\n- \"\"\"\n- Given the names of a DataFrame's rows and columns, returns a set of unique row\n- and column names and mappers that convert to original names.\n-\n- A row or column name is replaced if it is duplicate among the rows of the inputs,\n- among the columns of the inputs or between the rows and the columns.\n-\n- Parameters\n- ----------\n- rownames: list[str]\n- colnames: list[str]\n-\n- Returns\n- -------\n- Tuple(Dict[str, str], List[str], Dict[str, str], List[str])\n-\n- rownames_mapper: dict[str, str]\n- a dictionary with new row names as keys and original rownames as values\n- unique_rownames: list[str]\n- a list of rownames with duplicate names replaced by dummy names\n- colnames_mapper: dict[str, str]\n- a dictionary with new column names as keys and original column names as values\n- unique_colnames: list[str]\n- a list of column names with duplicate names replaced by dummy names\n-\n- \"\"\"\n-\n- def get_duplicates(names):\n- seen: set = set()\n- return {name for name in names if name not in seen}\n-\n- shared_names = set(rownames).intersection(set(colnames))\n- dup_names = get_duplicates(rownames) | get_duplicates(colnames) | shared_names\n-\n- rownames_mapper = {\n- f\"row_{i}\": name for i, name in enumerate(rownames) if name in dup_names\n- }\n- unique_rownames = [\n- f\"row_{i}\" if name in dup_names else name for i, name in enumerate(rownames)\n- ]\n-\n- colnames_mapper = {\n- f\"col_{i}\": name for i, name in enumerate(colnames) if name in dup_names\n- }\n- unique_colnames = [\n- f\"col_{i}\" if name in dup_names else name for i, name in enumerate(colnames)\n- ]\n-\n- return rownames_mapper, unique_rownames, colnames_mapper, unique_colnames\n+from pandas._core.reshape.pivot import *\ndiff --git a/pandas/core/reshape/reshape.py b/pandas/core/reshape/reshape.py\nindex b4e944861f1bc..6c6e07aa1708f 100644\n--- a/pandas/core/reshape/reshape.py\n+++ b/pandas/core/reshape/reshape.py\n@@ -1,838 +1 @@\n-from __future__ import annotations\n-\n-import itertools\n-from typing import TYPE_CHECKING\n-import warnings\n-\n-import numpy as np\n-\n-import pandas._libs.reshape as libreshape\n-from pandas._typing import npt\n-from pandas.errors import PerformanceWarning\n-from pandas.util._decorators import cache_readonly\n-\n-from pandas.core.dtypes.cast import maybe_promote\n-from pandas.core.dtypes.common import (\n- ensure_platform_int,\n- is_1d_only_ea_dtype,\n- is_extension_array_dtype,\n- is_integer,\n- needs_i8_conversion,\n-)\n-from pandas.core.dtypes.dtypes import ExtensionDtype\n-from pandas.core.dtypes.missing import notna\n-\n-import pandas.core.algorithms as algos\n-from pandas.core.arrays.categorical import factorize_from_iterable\n-from pandas.core.construction import ensure_wrapped_if_datetimelike\n-from pandas.core.frame import DataFrame\n-from pandas.core.indexes.api import (\n- Index,\n- MultiIndex,\n-)\n-from pandas.core.indexes.frozen import FrozenList\n-from pandas.core.series import Series\n-from pandas.core.sorting import (\n- compress_group_index,\n- decons_obs_group_ids,\n- get_compressed_ids,\n- get_group_index,\n- get_group_index_sorter,\n-)\n-\n-if TYPE_CHECKING:\n- from pandas.core.arrays import ExtensionArray\n-\n-\n-class _Unstacker:\n- \"\"\"\n- Helper class to unstack data / pivot with multi-level index\n-\n- Parameters\n- ----------\n- index : MultiIndex\n- level : int or str, default last level\n- Level to \"unstack\". Accepts a name for the level.\n- fill_value : scalar, optional\n- Default value to fill in missing values if subgroups do not have the\n- same set of labels. By default, missing values will be replaced with\n- the default fill value for that data type, NaN for float, NaT for\n- datetimelike, etc. For integer types, by default data will converted to\n- float and missing values will be set to NaN.\n- constructor : object\n- Pandas ``DataFrame`` or subclass used to create unstacked\n- response. If None, DataFrame will be used.\n-\n- Examples\n- --------\n- >>> index = pd.MultiIndex.from_tuples([('one', 'a'), ('one', 'b'),\n- ... ('two', 'a'), ('two', 'b')])\n- >>> s = pd.Series(np.arange(1, 5, dtype=np.int64), index=index)\n- >>> s\n- one a 1\n- b 2\n- two a 3\n- b 4\n- dtype: int64\n-\n- >>> s.unstack(level=-1)\n- a b\n- one 1 2\n- two 3 4\n-\n- >>> s.unstack(level=0)\n- one two\n- a 1 3\n- b 2 4\n-\n- Returns\n- -------\n- unstacked : DataFrame\n- \"\"\"\n-\n- def __init__(self, index: MultiIndex, level=-1, constructor=None) -> None:\n-\n- if constructor is None:\n- constructor = DataFrame\n- self.constructor = constructor\n-\n- self.index = index.remove_unused_levels()\n-\n- self.level = self.index._get_level_number(level)\n-\n- # when index includes `nan`, need to lift levels/strides by 1\n- self.lift = 1 if -1 in self.index.codes[self.level] else 0\n-\n- # Note: the \"pop\" below alters these in-place.\n- self.new_index_levels = list(self.index.levels)\n- self.new_index_names = list(self.index.names)\n-\n- self.removed_name = self.new_index_names.pop(self.level)\n- self.removed_level = self.new_index_levels.pop(self.level)\n- self.removed_level_full = index.levels[self.level]\n-\n- # Bug fix GH 20601\n- # If the data frame is too big, the number of unique index combination\n- # will cause int32 overflow on windows environments.\n- # We want to check and raise an error before this happens\n- num_rows = np.max([index_level.size for index_level in self.new_index_levels])\n- num_columns = self.removed_level.size\n-\n- # GH20601: This forces an overflow if the number of cells is too high.\n- num_cells = num_rows * num_columns\n-\n- # GH 26314: Previous ValueError raised was too restrictive for many users.\n- if num_cells > np.iinfo(np.int32).max:\n- warnings.warn(\n- f\"The following operation may generate {num_cells} cells \"\n- f\"in the resulting pandas object.\",\n- PerformanceWarning,\n- )\n-\n- self._make_selectors()\n-\n- @cache_readonly\n- def _indexer_and_to_sort(\n- self,\n- ) -> tuple[\n- npt.NDArray[np.intp],\n- list[np.ndarray], # each has _some_ signed integer dtype\n- ]:\n- v = self.level\n-\n- codes = list(self.index.codes)\n- levs = list(self.index.levels)\n- to_sort = codes[:v] + codes[v + 1 :] + [codes[v]]\n- sizes = tuple(len(x) for x in levs[:v] + levs[v + 1 :] + [levs[v]])\n-\n- comp_index, obs_ids = get_compressed_ids(to_sort, sizes)\n- ngroups = len(obs_ids)\n-\n- indexer = get_group_index_sorter(comp_index, ngroups)\n- return indexer, to_sort\n-\n- @cache_readonly\n- def sorted_labels(self):\n- indexer, to_sort = self._indexer_and_to_sort\n- return [line.take(indexer) for line in to_sort]\n-\n- def _make_sorted_values(self, values: np.ndarray) -> np.ndarray:\n- indexer, _ = self._indexer_and_to_sort\n-\n- sorted_values = algos.take_nd(values, indexer, axis=0)\n- return sorted_values\n-\n- def _make_selectors(self):\n- new_levels = self.new_index_levels\n-\n- # make the mask\n- remaining_labels = self.sorted_labels[:-1]\n- level_sizes = tuple(len(x) for x in new_levels)\n-\n- comp_index, obs_ids = get_compressed_ids(remaining_labels, level_sizes)\n- ngroups = len(obs_ids)\n-\n- comp_index = ensure_platform_int(comp_index)\n- stride = self.index.levshape[self.level] + self.lift\n- self.full_shape = ngroups, stride\n-\n- selector = self.sorted_labels[-1] + stride * comp_index + self.lift\n- mask = np.zeros(np.prod(self.full_shape), dtype=bool)\n- mask.put(selector, True)\n-\n- if mask.sum() < len(self.index):\n- raise ValueError(\"Index contains duplicate entries, cannot reshape\")\n-\n- self.group_index = comp_index\n- self.mask = mask\n- self.compressor = comp_index.searchsorted(np.arange(ngroups))\n-\n- @cache_readonly\n- def mask_all(self) -> bool:\n- return bool(self.mask.all())\n-\n- @cache_readonly\n- def arange_result(self) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.bool_]]:\n- # We cache this for re-use in ExtensionBlock._unstack\n- dummy_arr = np.arange(len(self.index), dtype=np.intp)\n- new_values, mask = self.get_new_values(dummy_arr, fill_value=-1)\n- return new_values, mask.any(0)\n- # TODO: in all tests we have mask.any(0).all(); can we rely on that?\n-\n- def get_result(self, values, value_columns, fill_value):\n-\n- if values.ndim == 1:\n- values = values[:, np.newaxis]\n-\n- if value_columns is None and values.shape[1] != 1: # pragma: no cover\n- raise ValueError(\"must pass column labels for multi-column data\")\n-\n- values, _ = self.get_new_values(values, fill_value)\n- columns = self.get_new_columns(value_columns)\n- index = self.new_index\n-\n- return self.constructor(\n- values, index=index, columns=columns, dtype=values.dtype\n- )\n-\n- def get_new_values(self, values, fill_value=None):\n-\n- if values.ndim == 1:\n- values = values[:, np.newaxis]\n-\n- sorted_values = self._make_sorted_values(values)\n-\n- # place the values\n- length, width = self.full_shape\n- stride = values.shape[1]\n- result_width = width * stride\n- result_shape = (length, result_width)\n- mask = self.mask\n- mask_all = self.mask_all\n-\n- # we can simply reshape if we don't have a mask\n- if mask_all and len(values):\n- # TODO: Under what circumstances can we rely on sorted_values\n- # matching values? When that holds, we can slice instead\n- # of take (in particular for EAs)\n- new_values = (\n- sorted_values.reshape(length, width, stride)\n- .swapaxes(1, 2)\n- .reshape(result_shape)\n- )\n- new_mask = np.ones(result_shape, dtype=bool)\n- return new_values, new_mask\n-\n- dtype = values.dtype\n-\n- # if our mask is all True, then we can use our existing dtype\n- if mask_all:\n- dtype = values.dtype\n- new_values = np.empty(result_shape, dtype=dtype)\n- else:\n- if isinstance(dtype, ExtensionDtype):\n- # GH#41875\n- # We are assuming that fill_value can be held by this dtype,\n- # unlike the non-EA case that promotes.\n- cls = dtype.construct_array_type()\n- new_values = cls._empty(result_shape, dtype=dtype)\n- new_values[:] = fill_value\n- else:\n- dtype, fill_value = maybe_promote(dtype, fill_value)\n- new_values = np.empty(result_shape, dtype=dtype)\n- new_values.fill(fill_value)\n-\n- name = dtype.name\n- new_mask = np.zeros(result_shape, dtype=bool)\n-\n- # we need to convert to a basic dtype\n- # and possibly coerce an input to our output dtype\n- # e.g. ints -> floats\n- if needs_i8_conversion(values.dtype):\n- sorted_values = sorted_values.view(\"i8\")\n- new_values = new_values.view(\"i8\")\n- else:\n- sorted_values = sorted_values.astype(name, copy=False)\n-\n- # fill in our values & mask\n- libreshape.unstack(\n- sorted_values,\n- mask.view(\"u1\"),\n- stride,\n- length,\n- width,\n- new_values,\n- new_mask.view(\"u1\"),\n- )\n-\n- # reconstruct dtype if needed\n- if needs_i8_conversion(values.dtype):\n- # view as datetime64 so we can wrap in DatetimeArray and use\n- # DTA's view method\n- new_values = new_values.view(\"M8[ns]\")\n- new_values = ensure_wrapped_if_datetimelike(new_values)\n- new_values = new_values.view(values.dtype)\n-\n- return new_values, new_mask\n-\n- def get_new_columns(self, value_columns: Index | None):\n- if value_columns is None:\n- if self.lift == 0:\n- return self.removed_level._rename(name=self.removed_name)\n-\n- lev = self.removed_level.insert(0, item=self.removed_level._na_value)\n- return lev.rename(self.removed_name)\n-\n- stride = len(self.removed_level) + self.lift\n- width = len(value_columns)\n- propagator = np.repeat(np.arange(width), stride)\n-\n- new_levels: FrozenList | list[Index]\n-\n- if isinstance(value_columns, MultiIndex):\n- new_levels = value_columns.levels + (self.removed_level_full,)\n- new_names = value_columns.names + (self.removed_name,)\n-\n- new_codes = [lab.take(propagator) for lab in value_columns.codes]\n- else:\n- new_levels = [\n- value_columns,\n- self.removed_level_full,\n- ]\n- new_names = [value_columns.name, self.removed_name]\n- new_codes = [propagator]\n-\n- repeater = self._repeater\n-\n- # The entire level is then just a repetition of the single chunk:\n- new_codes.append(np.tile(repeater, width))\n- return MultiIndex(\n- levels=new_levels, codes=new_codes, names=new_names, verify_integrity=False\n- )\n-\n- @cache_readonly\n- def _repeater(self) -> np.ndarray:\n- # The two indices differ only if the unstacked level had unused items:\n- if len(self.removed_level_full) != len(self.removed_level):\n- # In this case, we remap the new codes to the original level:\n- repeater = self.removed_level_full.get_indexer(self.removed_level)\n- if self.lift:\n- repeater = np.insert(repeater, 0, -1)\n- else:\n- # Otherwise, we just use each level item exactly once:\n- stride = len(self.removed_level) + self.lift\n- repeater = np.arange(stride) - self.lift\n-\n- return repeater\n-\n- @cache_readonly\n- def new_index(self):\n- # Does not depend on values or value_columns\n- result_codes = [lab.take(self.compressor) for lab in self.sorted_labels[:-1]]\n-\n- # construct the new index\n- if len(self.new_index_levels) == 1:\n- level, level_codes = self.new_index_levels[0], result_codes[0]\n- if (level_codes == -1).any():\n- level = level.insert(len(level), level._na_value)\n- return level.take(level_codes).rename(self.new_index_names[0])\n-\n- return MultiIndex(\n- levels=self.new_index_levels,\n- codes=result_codes,\n- names=self.new_index_names,\n- verify_integrity=False,\n- )\n-\n-\n-def _unstack_multiple(data, clocs, fill_value=None):\n- if len(clocs) == 0:\n- return data\n-\n- # NOTE: This doesn't deal with hierarchical columns yet\n-\n- index = data.index\n-\n- # GH 19966 Make sure if MultiIndexed index has tuple name, they will be\n- # recognised as a whole\n- if clocs in index.names:\n- clocs = [clocs]\n- clocs = [index._get_level_number(i) for i in clocs]\n-\n- rlocs = [i for i in range(index.nlevels) if i not in clocs]\n-\n- clevels = [index.levels[i] for i in clocs]\n- ccodes = [index.codes[i] for i in clocs]\n- cnames = [index.names[i] for i in clocs]\n- rlevels = [index.levels[i] for i in rlocs]\n- rcodes = [index.codes[i] for i in rlocs]\n- rnames = [index.names[i] for i in rlocs]\n-\n- shape = tuple(len(x) for x in clevels)\n- group_index = get_group_index(ccodes, shape, sort=False, xnull=False)\n-\n- comp_ids, obs_ids = compress_group_index(group_index, sort=False)\n- recons_codes = decons_obs_group_ids(comp_ids, obs_ids, shape, ccodes, xnull=False)\n-\n- if not rlocs:\n- # Everything is in clocs, so the dummy df has a regular index\n- dummy_index = Index(obs_ids, name=\"__placeholder__\")\n- else:\n- dummy_index = MultiIndex(\n- levels=rlevels + [obs_ids],\n- codes=rcodes + [comp_ids],\n- names=rnames + [\"__placeholder__\"],\n- verify_integrity=False,\n- )\n-\n- if isinstance(data, Series):\n- dummy = data.copy()\n- dummy.index = dummy_index\n-\n- unstacked = dummy.unstack(\"__placeholder__\", fill_value=fill_value)\n- new_levels = clevels\n- new_names = cnames\n- new_codes = recons_codes\n- else:\n- if isinstance(data.columns, MultiIndex):\n- result = data\n- for i in range(len(clocs)):\n- val = clocs[i]\n- result = result.unstack(val, fill_value=fill_value)\n- clocs = [v if v < val else v - 1 for v in clocs]\n-\n- return result\n-\n- # GH#42579 deep=False to avoid consolidating\n- dummy = data.copy(deep=False)\n- dummy.index = dummy_index\n-\n- unstacked = dummy.unstack(\"__placeholder__\", fill_value=fill_value)\n- if isinstance(unstacked, Series):\n- unstcols = unstacked.index\n- else:\n- unstcols = unstacked.columns\n- assert isinstance(unstcols, MultiIndex) # for mypy\n- new_levels = [unstcols.levels[0]] + clevels\n- new_names = [data.columns.name] + cnames\n-\n- new_codes = [unstcols.codes[0]]\n- for rec in recons_codes:\n- new_codes.append(rec.take(unstcols.codes[-1]))\n-\n- new_columns = MultiIndex(\n- levels=new_levels, codes=new_codes, names=new_names, verify_integrity=False\n- )\n-\n- if isinstance(unstacked, Series):\n- unstacked.index = new_columns\n- else:\n- unstacked.columns = new_columns\n-\n- return unstacked\n-\n-\n-def unstack(obj, level, fill_value=None):\n-\n- if isinstance(level, (tuple, list)):\n- if len(level) != 1:\n- # _unstack_multiple only handles MultiIndexes,\n- # and isn't needed for a single level\n- return _unstack_multiple(obj, level, fill_value=fill_value)\n- else:\n- level = level[0]\n-\n- # Prioritize integer interpretation (GH #21677):\n- if not is_integer(level) and not level == \"__placeholder__\":\n- level = obj.index._get_level_number(level)\n-\n- if isinstance(obj, DataFrame):\n- if isinstance(obj.index, MultiIndex):\n- return _unstack_frame(obj, level, fill_value=fill_value)\n- else:\n- return obj.T.stack(dropna=False)\n- elif not isinstance(obj.index, MultiIndex):\n- # GH 36113\n- # Give nicer error messages when unstack a Series whose\n- # Index is not a MultiIndex.\n- raise ValueError(\n- f\"index must be a MultiIndex to unstack, {type(obj.index)} was passed\"\n- )\n- else:\n- if is_1d_only_ea_dtype(obj.dtype):\n- return _unstack_extension_series(obj, level, fill_value)\n- unstacker = _Unstacker(\n- obj.index, level=level, constructor=obj._constructor_expanddim\n- )\n- return unstacker.get_result(\n- obj._values, value_columns=None, fill_value=fill_value\n- )\n-\n-\n-def _unstack_frame(obj, level, fill_value=None):\n- if not obj._can_fast_transpose:\n- unstacker = _Unstacker(obj.index, level=level)\n- mgr = obj._mgr.unstack(unstacker, fill_value=fill_value)\n- return obj._constructor(mgr)\n- else:\n- unstacker = _Unstacker(obj.index, level=level, constructor=obj._constructor)\n- return unstacker.get_result(\n- obj._values, value_columns=obj.columns, fill_value=fill_value\n- )\n-\n-\n-def _unstack_extension_series(series, level, fill_value):\n- \"\"\"\n- Unstack an ExtensionArray-backed Series.\n-\n- The ExtensionDtype is preserved.\n-\n- Parameters\n- ----------\n- series : Series\n- A Series with an ExtensionArray for values\n- level : Any\n- The level name or number.\n- fill_value : Any\n- The user-level (not physical storage) fill value to use for\n- missing values introduced by the reshape. Passed to\n- ``series.values.take``.\n-\n- Returns\n- -------\n- DataFrame\n- Each column of the DataFrame will have the same dtype as\n- the input Series.\n- \"\"\"\n- # Defer to the logic in ExtensionBlock._unstack\n- df = series.to_frame()\n- result = df.unstack(level=level, fill_value=fill_value)\n-\n- # equiv: result.droplevel(level=0, axis=1)\n- # but this avoids an extra copy\n- result.columns = result.columns.droplevel(0)\n- return result\n-\n-\n-def stack(frame, level=-1, dropna=True):\n- \"\"\"\n- Convert DataFrame to Series with multi-level Index. Columns become the\n- second level of the resulting hierarchical index\n-\n- Returns\n- -------\n- stacked : Series\n- \"\"\"\n-\n- def factorize(index):\n- if index.is_unique:\n- return index, np.arange(len(index))\n- codes, categories = factorize_from_iterable(index)\n- return categories, codes\n-\n- N, K = frame.shape\n-\n- # Will also convert negative level numbers and check if out of bounds.\n- level_num = frame.columns._get_level_number(level)\n-\n- if isinstance(frame.columns, MultiIndex):\n- return _stack_multi_columns(frame, level_num=level_num, dropna=dropna)\n- elif isinstance(frame.index, MultiIndex):\n- new_levels = list(frame.index.levels)\n- new_codes = [lab.repeat(K) for lab in frame.index.codes]\n-\n- clev, clab = factorize(frame.columns)\n- new_levels.append(clev)\n- new_codes.append(np.tile(clab, N).ravel())\n-\n- new_names = list(frame.index.names)\n- new_names.append(frame.columns.name)\n- new_index = MultiIndex(\n- levels=new_levels, codes=new_codes, names=new_names, verify_integrity=False\n- )\n- else:\n- levels, (ilab, clab) = zip(*map(factorize, (frame.index, frame.columns)))\n- codes = ilab.repeat(K), np.tile(clab, N).ravel()\n- new_index = MultiIndex(\n- levels=levels,\n- codes=codes,\n- names=[frame.index.name, frame.columns.name],\n- verify_integrity=False,\n- )\n-\n- if not frame.empty and frame._is_homogeneous_type:\n- # For homogeneous EAs, frame._values will coerce to object. So\n- # we concatenate instead.\n- dtypes = list(frame.dtypes._values)\n- dtype = dtypes[0]\n-\n- if is_extension_array_dtype(dtype):\n- arr = dtype.construct_array_type()\n- new_values = arr._concat_same_type(\n- [col._values for _, col in frame.items()]\n- )\n- new_values = _reorder_for_extension_array_stack(new_values, N, K)\n- else:\n- # homogeneous, non-EA\n- new_values = frame._values.ravel()\n-\n- else:\n- # non-homogeneous\n- new_values = frame._values.ravel()\n-\n- if dropna:\n- mask = notna(new_values)\n- new_values = new_values[mask]\n- new_index = new_index[mask]\n-\n- return frame._constructor_sliced(new_values, index=new_index)\n-\n-\n-def stack_multiple(frame, level, dropna=True):\n- # If all passed levels match up to column names, no\n- # ambiguity about what to do\n- if all(lev in frame.columns.names for lev in level):\n- result = frame\n- for lev in level:\n- result = stack(result, lev, dropna=dropna)\n-\n- # Otherwise, level numbers may change as each successive level is stacked\n- elif all(isinstance(lev, int) for lev in level):\n- # As each stack is done, the level numbers decrease, so we need\n- # to account for that when level is a sequence of ints\n- result = frame\n- # _get_level_number() checks level numbers are in range and converts\n- # negative numbers to positive\n- level = [frame.columns._get_level_number(lev) for lev in level]\n-\n- # Can't iterate directly through level as we might need to change\n- # values as we go\n- for index in range(len(level)):\n- lev = level[index]\n- result = stack(result, lev, dropna=dropna)\n- # Decrement all level numbers greater than current, as these\n- # have now shifted down by one\n- updated_level = []\n- for other in level:\n- if other > lev:\n- updated_level.append(other - 1)\n- else:\n- updated_level.append(other)\n- level = updated_level\n-\n- else:\n- raise ValueError(\n- \"level should contain all level names or all level \"\n- \"numbers, not a mixture of the two.\"\n- )\n-\n- return result\n-\n-\n-def _stack_multi_column_index(columns: MultiIndex) -> MultiIndex:\n- \"\"\"Creates a MultiIndex from the first N-1 levels of this MultiIndex.\"\"\"\n- if len(columns.levels) <= 2:\n- return columns.levels[0]._rename(name=columns.names[0])\n-\n- levs = [\n- [lev[c] if c >= 0 else None for c in codes]\n- for lev, codes in zip(columns.levels[:-1], columns.codes[:-1])\n- ]\n-\n- # Remove duplicate tuples in the MultiIndex.\n- tuples = zip(*levs)\n- unique_tuples = (key for key, _ in itertools.groupby(tuples))\n- new_levs = zip(*unique_tuples)\n-\n- # The dtype of each level must be explicitly set to avoid inferring the wrong type.\n- # See GH-36991.\n- return MultiIndex.from_arrays(\n- [\n- # Not all indices can accept None values.\n- Index(new_lev, dtype=lev.dtype) if None not in new_lev else new_lev\n- for new_lev, lev in zip(new_levs, columns.levels)\n- ],\n- names=columns.names[:-1],\n- )\n-\n-\n-def _stack_multi_columns(frame, level_num=-1, dropna=True):\n- def _convert_level_number(level_num: int, columns):\n- \"\"\"\n- Logic for converting the level number to something we can safely pass\n- to swaplevel.\n-\n- If `level_num` matches a column name return the name from\n- position `level_num`, otherwise return `level_num`.\n- \"\"\"\n- if level_num in columns.names:\n- return columns.names[level_num]\n-\n- return level_num\n-\n- this = frame.copy()\n-\n- # this makes life much simpler\n- if level_num != frame.columns.nlevels - 1:\n- # roll levels to put selected level at end\n- roll_columns = this.columns\n- for i in range(level_num, frame.columns.nlevels - 1):\n- # Need to check if the ints conflict with level names\n- lev1 = _convert_level_number(i, roll_columns)\n- lev2 = _convert_level_number(i + 1, roll_columns)\n- roll_columns = roll_columns.swaplevel(lev1, lev2)\n- this.columns = roll_columns\n-\n- if not this.columns._is_lexsorted():\n- # Workaround the edge case where 0 is one of the column names,\n- # which interferes with trying to sort based on the first\n- # level\n- level_to_sort = _convert_level_number(0, this.columns)\n- this = this.sort_index(level=level_to_sort, axis=1)\n-\n- new_columns = _stack_multi_column_index(this.columns)\n-\n- # time to ravel the values\n- new_data = {}\n- level_vals = this.columns.levels[-1]\n- level_codes = sorted(set(this.columns.codes[-1]))\n- level_vals_nan = level_vals.insert(len(level_vals), None)\n-\n- level_vals_used = np.take(level_vals_nan, level_codes)\n- levsize = len(level_codes)\n- drop_cols = []\n- for key in new_columns:\n- try:\n- loc = this.columns.get_loc(key)\n- except KeyError:\n- drop_cols.append(key)\n- continue\n-\n- # can make more efficient?\n- # we almost always return a slice\n- # but if unsorted can get a boolean\n- # indexer\n- if not isinstance(loc, slice):\n- slice_len = len(loc)\n- else:\n- slice_len = loc.stop - loc.start\n-\n- if slice_len != levsize:\n- chunk = this.loc[:, this.columns[loc]]\n- chunk.columns = level_vals_nan.take(chunk.columns.codes[-1])\n- value_slice = chunk.reindex(columns=level_vals_used).values\n- else:\n- if frame._is_homogeneous_type and is_extension_array_dtype(\n- frame.dtypes.iloc[0]\n- ):\n- # TODO(EA2D): won't need special case, can go through .values\n- # paths below (might change to ._values)\n- dtype = this[this.columns[loc]].dtypes.iloc[0]\n- subset = this[this.columns[loc]]\n-\n- value_slice = dtype.construct_array_type()._concat_same_type(\n- [x._values for _, x in subset.items()]\n- )\n- N, K = subset.shape\n- idx = np.arange(N * K).reshape(K, N).T.ravel()\n- value_slice = value_slice.take(idx)\n-\n- elif frame._is_mixed_type:\n- value_slice = this[this.columns[loc]].values\n- else:\n- value_slice = this.values[:, loc]\n-\n- if value_slice.ndim > 1:\n- # i.e. not extension\n- value_slice = value_slice.ravel()\n-\n- new_data[key] = value_slice\n-\n- if len(drop_cols) > 0:\n- new_columns = new_columns.difference(drop_cols)\n-\n- N = len(this)\n-\n- if isinstance(this.index, MultiIndex):\n- new_levels = list(this.index.levels)\n- new_names = list(this.index.names)\n- new_codes = [lab.repeat(levsize) for lab in this.index.codes]\n- else:\n- old_codes, old_levels = factorize_from_iterable(this.index)\n- new_levels = [old_levels]\n- new_codes = [old_codes.repeat(levsize)]\n- new_names = [this.index.name] # something better?\n-\n- new_levels.append(level_vals)\n- new_codes.append(np.tile(level_codes, N))\n- new_names.append(frame.columns.names[level_num])\n-\n- new_index = MultiIndex(\n- levels=new_levels, codes=new_codes, names=new_names, verify_integrity=False\n- )\n-\n- result = frame._constructor(new_data, index=new_index, columns=new_columns)\n-\n- # more efficient way to go about this? can do the whole masking biz but\n- # will only save a small amount of time...\n- if dropna:\n- result = result.dropna(axis=0, how=\"all\")\n-\n- return result\n-\n-\n-def _reorder_for_extension_array_stack(\n- arr: ExtensionArray, n_rows: int, n_columns: int\n-) -> ExtensionArray:\n- \"\"\"\n- Re-orders the values when stacking multiple extension-arrays.\n-\n- The indirect stacking method used for EAs requires a followup\n- take to get the order correct.\n-\n- Parameters\n- ----------\n- arr : ExtensionArray\n- n_rows, n_columns : int\n- The number of rows and columns in the original DataFrame.\n-\n- Returns\n- -------\n- taken : ExtensionArray\n- The original `arr` with elements re-ordered appropriately\n-\n- Examples\n- --------\n- >>> arr = np.array(['a', 'b', 'c', 'd', 'e', 'f'])\n- >>> _reorder_for_extension_array_stack(arr, 2, 3)\n- array(['a', 'c', 'e', 'b', 'd', 'f'], dtype='<U1')\n-\n- >>> _reorder_for_extension_array_stack(arr, 3, 2)\n- array(['a', 'd', 'b', 'e', 'c', 'f'], dtype='<U1')\n- \"\"\"\n- # final take to get the order correct.\n- # idx is an indexer like\n- # [c0r0, c1r0, c2r0, ...,\n- # c0r1, c1r1, c2r1, ...]\n- idx = np.arange(n_rows * n_columns).reshape(n_columns, n_rows).T.ravel()\n- return arr.take(idx)\n+from pandas._core.reshape.reshape import *\ndiff --git a/pandas/core/reshape/tile.py b/pandas/core/reshape/tile.py\nindex 00b2b30eb3122..e4c98fef2be6a 100644\n--- a/pandas/core/reshape/tile.py\n+++ b/pandas/core/reshape/tile.py\n@@ -1,647 +1 @@\n-\"\"\"\n-Quantilization functions and related stuff\n-\"\"\"\n-from __future__ import annotations\n-\n-from typing import (\n- Any,\n- Callable,\n- Literal,\n-)\n-\n-import numpy as np\n-\n-from pandas._libs import (\n- Timedelta,\n- Timestamp,\n-)\n-from pandas._libs.lib import infer_dtype\n-from pandas._typing import IntervalLeftRight\n-\n-from pandas.core.dtypes.common import (\n- DT64NS_DTYPE,\n- ensure_platform_int,\n- is_bool_dtype,\n- is_categorical_dtype,\n- is_datetime64_dtype,\n- is_datetime64tz_dtype,\n- is_datetime_or_timedelta_dtype,\n- is_extension_array_dtype,\n- is_integer,\n- is_list_like,\n- is_numeric_dtype,\n- is_scalar,\n- is_timedelta64_dtype,\n-)\n-from pandas.core.dtypes.generic import ABCSeries\n-from pandas.core.dtypes.missing import isna\n-\n-from pandas import (\n- Categorical,\n- Index,\n- IntervalIndex,\n- to_datetime,\n- to_timedelta,\n-)\n-import pandas.core.algorithms as algos\n-import pandas.core.nanops as nanops\n-\n-\n-def cut(\n- x,\n- bins,\n- right: bool = True,\n- labels=None,\n- retbins: bool = False,\n- precision: int = 3,\n- include_lowest: bool = False,\n- duplicates: str = \"raise\",\n- ordered: bool = True,\n-):\n- \"\"\"\n- Bin values into discrete intervals.\n-\n- Use `cut` when you need to segment and sort data values into bins. This\n- function is also useful for going from a continuous variable to a\n- categorical variable. For example, `cut` could convert ages to groups of\n- age ranges. Supports binning into an equal number of bins, or a\n- pre-specified array of bins.\n-\n- Parameters\n- ----------\n- x : array-like\n- The input array to be binned. Must be 1-dimensional.\n- bins : int, sequence of scalars, or IntervalIndex\n- The criteria to bin by.\n-\n- * int : Defines the number of equal-width bins in the range of `x`. The\n- range of `x` is extended by .1% on each side to include the minimum\n- and maximum values of `x`.\n- * sequence of scalars : Defines the bin edges allowing for non-uniform\n- width. No extension of the range of `x` is done.\n- * IntervalIndex : Defines the exact bins to be used. Note that\n- IntervalIndex for `bins` must be non-overlapping.\n-\n- right : bool, default True\n- Indicates whether `bins` includes the rightmost edge or not. If\n- ``right == True`` (the default), then the `bins` ``[1, 2, 3, 4]``\n- indicate (1,2], (2,3], (3,4]. This argument is ignored when\n- `bins` is an IntervalIndex.\n- labels : array or False, default None\n- Specifies the labels for the returned bins. Must be the same length as\n- the resulting bins. If False, returns only integer indicators of the\n- bins. This affects the type of the output container (see below).\n- This argument is ignored when `bins` is an IntervalIndex. If True,\n- raises an error. When `ordered=False`, labels must be provided.\n- retbins : bool, default False\n- Whether to return the bins or not. Useful when bins is provided\n- as a scalar.\n- precision : int, default 3\n- The precision at which to store and display the bins labels.\n- include_lowest : bool, default False\n- Whether the first interval should be left-inclusive or not.\n- duplicates : {default 'raise', 'drop'}, optional\n- If bin edges are not unique, raise ValueError or drop non-uniques.\n- ordered : bool, default True\n- Whether the labels are ordered or not. Applies to returned types\n- Categorical and Series (with Categorical dtype). If True,\n- the resulting categorical will be ordered. If False, the resulting\n- categorical will be unordered (labels must be provided).\n-\n- .. versionadded:: 1.1.0\n-\n- Returns\n- -------\n- out : Categorical, Series, or ndarray\n- An array-like object representing the respective bin for each value\n- of `x`. The type depends on the value of `labels`.\n-\n- * None (default) : returns a Series for Series `x` or a\n- Categorical for all other inputs. The values stored within\n- are Interval dtype.\n-\n- * sequence of scalars : returns a Series for Series `x` or a\n- Categorical for all other inputs. The values stored within\n- are whatever the type in the sequence is.\n-\n- * False : returns an ndarray of integers.\n-\n- bins : numpy.ndarray or IntervalIndex.\n- The computed or specified bins. Only returned when `retbins=True`.\n- For scalar or sequence `bins`, this is an ndarray with the computed\n- bins. If set `duplicates=drop`, `bins` will drop non-unique bin. For\n- an IntervalIndex `bins`, this is equal to `bins`.\n-\n- See Also\n- --------\n- qcut : Discretize variable into equal-sized buckets based on rank\n- or based on sample quantiles.\n- Categorical : Array type for storing data that come from a\n- fixed set of values.\n- Series : One-dimensional array with axis labels (including time series).\n- IntervalIndex : Immutable Index implementing an ordered, sliceable set.\n-\n- Notes\n- -----\n- Any NA values will be NA in the result. Out of bounds values will be NA in\n- the resulting Series or Categorical object.\n-\n- Reference :ref:`the user guide <reshaping.tile.cut>` for more examples.\n-\n- Examples\n- --------\n- Discretize into three equal-sized bins.\n-\n- >>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3)\n- ... # doctest: +ELLIPSIS\n- [(0.994, 3.0], (5.0, 7.0], (3.0, 5.0], (3.0, 5.0], (5.0, 7.0], ...\n- Categories (3, interval[float64, right]): [(0.994, 3.0] < (3.0, 5.0] ...\n-\n- >>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3, retbins=True)\n- ... # doctest: +ELLIPSIS\n- ([(0.994, 3.0], (5.0, 7.0], (3.0, 5.0], (3.0, 5.0], (5.0, 7.0], ...\n- Categories (3, interval[float64, right]): [(0.994, 3.0] < (3.0, 5.0] ...\n- array([0.994, 3. , 5. , 7. ]))\n-\n- Discovers the same bins, but assign them specific labels. Notice that\n- the returned Categorical's categories are `labels` and is ordered.\n-\n- >>> pd.cut(np.array([1, 7, 5, 4, 6, 3]),\n- ... 3, labels=[\"bad\", \"medium\", \"good\"])\n- ['bad', 'good', 'medium', 'medium', 'good', 'bad']\n- Categories (3, object): ['bad' < 'medium' < 'good']\n-\n- ``ordered=False`` will result in unordered categories when labels are passed.\n- This parameter can be used to allow non-unique labels:\n-\n- >>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3,\n- ... labels=[\"B\", \"A\", \"B\"], ordered=False)\n- ['B', 'B', 'A', 'A', 'B', 'B']\n- Categories (2, object): ['A', 'B']\n-\n- ``labels=False`` implies you just want the bins back.\n-\n- >>> pd.cut([0, 1, 1, 2], bins=4, labels=False)\n- array([0, 1, 1, 3])\n-\n- Passing a Series as an input returns a Series with categorical dtype:\n-\n- >>> s = pd.Series(np.array([2, 4, 6, 8, 10]),\n- ... index=['a', 'b', 'c', 'd', 'e'])\n- >>> pd.cut(s, 3)\n- ... # doctest: +ELLIPSIS\n- a (1.992, 4.667]\n- b (1.992, 4.667]\n- c (4.667, 7.333]\n- d (7.333, 10.0]\n- e (7.333, 10.0]\n- dtype: category\n- Categories (3, interval[float64, right]): [(1.992, 4.667] < (4.667, ...\n-\n- Passing a Series as an input returns a Series with mapping value.\n- It is used to map numerically to intervals based on bins.\n-\n- >>> s = pd.Series(np.array([2, 4, 6, 8, 10]),\n- ... index=['a', 'b', 'c', 'd', 'e'])\n- >>> pd.cut(s, [0, 2, 4, 6, 8, 10], labels=False, retbins=True, right=False)\n- ... # doctest: +ELLIPSIS\n- (a 1.0\n- b 2.0\n- c 3.0\n- d 4.0\n- e NaN\n- dtype: float64,\n- array([ 0, 2, 4, 6, 8, 10]))\n-\n- Use `drop` optional when bins is not unique\n-\n- >>> pd.cut(s, [0, 2, 4, 6, 10, 10], labels=False, retbins=True,\n- ... right=False, duplicates='drop')\n- ... # doctest: +ELLIPSIS\n- (a 1.0\n- b 2.0\n- c 3.0\n- d 3.0\n- e NaN\n- dtype: float64,\n- array([ 0, 2, 4, 6, 10]))\n-\n- Passing an IntervalIndex for `bins` results in those categories exactly.\n- Notice that values not covered by the IntervalIndex are set to NaN. 0\n- is to the left of the first bin (which is closed on the right), and 1.5\n- falls between two bins.\n-\n- >>> bins = pd.IntervalIndex.from_tuples([(0, 1), (2, 3), (4, 5)], inclusive=\"right\")\n- >>> pd.cut([0, 0.5, 1.5, 2.5, 4.5], bins)\n- [NaN, (0.0, 1.0], NaN, (2.0, 3.0], (4.0, 5.0]]\n- Categories (3, interval[int64, right]): [(0, 1] < (2, 3] < (4, 5]]\n- \"\"\"\n- # NOTE: this binning code is changed a bit from histogram for var(x) == 0\n-\n- original = x\n- x = _preprocess_for_cut(x)\n- x, dtype = _coerce_to_type(x)\n-\n- if not np.iterable(bins):\n- if is_scalar(bins) and bins < 1:\n- raise ValueError(\"`bins` should be a positive integer.\")\n-\n- try: # for array-like\n- sz = x.size\n- except AttributeError:\n- x = np.asarray(x)\n- sz = x.size\n-\n- if sz == 0:\n- raise ValueError(\"Cannot cut empty array\")\n-\n- rng = (nanops.nanmin(x), nanops.nanmax(x))\n- mn, mx = (mi + 0.0 for mi in rng)\n-\n- if np.isinf(mn) or np.isinf(mx):\n- # GH 24314\n- raise ValueError(\n- \"cannot specify integer `bins` when input data contains infinity\"\n- )\n- elif mn == mx: # adjust end points before binning\n- mn -= 0.001 * abs(mn) if mn != 0 else 0.001\n- mx += 0.001 * abs(mx) if mx != 0 else 0.001\n- bins = np.linspace(mn, mx, bins + 1, endpoint=True)\n- else: # adjust end points after binning\n- bins = np.linspace(mn, mx, bins + 1, endpoint=True)\n- adj = (mx - mn) * 0.001 # 0.1% of the range\n- if right:\n- bins[0] -= adj\n- else:\n- bins[-1] += adj\n-\n- elif isinstance(bins, IntervalIndex):\n- if bins.is_overlapping:\n- raise ValueError(\"Overlapping IntervalIndex is not accepted.\")\n-\n- else:\n- if is_datetime64tz_dtype(bins):\n- bins = np.asarray(bins, dtype=DT64NS_DTYPE)\n- else:\n- bins = np.asarray(bins)\n- bins = _convert_bin_to_numeric_type(bins, dtype)\n-\n- # GH 26045: cast to float64 to avoid an overflow\n- if (np.diff(bins.astype(\"float64\")) < 0).any():\n- raise ValueError(\"bins must increase monotonically.\")\n-\n- fac, bins = _bins_to_cuts(\n- x,\n- bins,\n- right=right,\n- labels=labels,\n- precision=precision,\n- include_lowest=include_lowest,\n- dtype=dtype,\n- duplicates=duplicates,\n- ordered=ordered,\n- )\n-\n- return _postprocess_for_cut(fac, bins, retbins, dtype, original)\n-\n-\n-def qcut(\n- x,\n- q,\n- labels=None,\n- retbins: bool = False,\n- precision: int = 3,\n- duplicates: str = \"raise\",\n-):\n- \"\"\"\n- Quantile-based discretization function.\n-\n- Discretize variable into equal-sized buckets based on rank or based\n- on sample quantiles. For example 1000 values for 10 quantiles would\n- produce a Categorical object indicating quantile membership for each data point.\n-\n- Parameters\n- ----------\n- x : 1d ndarray or Series\n- q : int or list-like of float\n- Number of quantiles. 10 for deciles, 4 for quartiles, etc. Alternately\n- array of quantiles, e.g. [0, .25, .5, .75, 1.] for quartiles.\n- labels : array or False, default None\n- Used as labels for the resulting bins. Must be of the same length as\n- the resulting bins. If False, return only integer indicators of the\n- bins. If True, raises an error.\n- retbins : bool, optional\n- Whether to return the (bins, labels) or not. Can be useful if bins\n- is given as a scalar.\n- precision : int, optional\n- The precision at which to store and display the bins labels.\n- duplicates : {default 'raise', 'drop'}, optional\n- If bin edges are not unique, raise ValueError or drop non-uniques.\n-\n- Returns\n- -------\n- out : Categorical or Series or array of integers if labels is False\n- The return type (Categorical or Series) depends on the input: a Series\n- of type category if input is a Series else Categorical. Bins are\n- represented as categories when categorical data is returned.\n- bins : ndarray of floats\n- Returned only if `retbins` is True.\n-\n- Notes\n- -----\n- Out of bounds values will be NA in the resulting Categorical object\n-\n- Examples\n- --------\n- >>> pd.qcut(range(5), 4)\n- ... # doctest: +ELLIPSIS\n- [(-0.001, 1.0], (-0.001, 1.0], (1.0, 2.0], (2.0, 3.0], (3.0, 4.0]]\n- Categories (4, interval[float64, right]): [(-0.001, 1.0] < (1.0, 2.0] ...\n-\n- >>> pd.qcut(range(5), 3, labels=[\"good\", \"medium\", \"bad\"])\n- ... # doctest: +SKIP\n- [good, good, medium, bad, bad]\n- Categories (3, object): [good < medium < bad]\n-\n- >>> pd.qcut(range(5), 4, labels=False)\n- array([0, 0, 1, 2, 3])\n- \"\"\"\n- original = x\n- x = _preprocess_for_cut(x)\n- x, dtype = _coerce_to_type(x)\n-\n- quantiles = np.linspace(0, 1, q + 1) if is_integer(q) else q\n-\n- x_np = np.asarray(x)\n- x_np = x_np[~np.isnan(x_np)]\n- bins = np.quantile(x_np, quantiles)\n-\n- fac, bins = _bins_to_cuts(\n- x,\n- bins,\n- labels=labels,\n- precision=precision,\n- include_lowest=True,\n- dtype=dtype,\n- duplicates=duplicates,\n- )\n-\n- return _postprocess_for_cut(fac, bins, retbins, dtype, original)\n-\n-\n-def _bins_to_cuts(\n- x,\n- bins: np.ndarray,\n- right: bool = True,\n- labels=None,\n- precision: int = 3,\n- include_lowest: bool = False,\n- dtype=None,\n- duplicates: str = \"raise\",\n- ordered: bool = True,\n-):\n- if not ordered and labels is None:\n- raise ValueError(\"'labels' must be provided if 'ordered = False'\")\n-\n- if duplicates not in [\"raise\", \"drop\"]:\n- raise ValueError(\n- \"invalid value for 'duplicates' parameter, valid options are: raise, drop\"\n- )\n-\n- if isinstance(bins, IntervalIndex):\n- # we have a fast-path here\n- ids = bins.get_indexer(x)\n- result = Categorical.from_codes(ids, categories=bins, ordered=True)\n- return result, bins\n-\n- unique_bins = algos.unique(bins)\n- if len(unique_bins) < len(bins) and len(bins) != 2:\n- if duplicates == \"raise\":\n- raise ValueError(\n- f\"Bin edges must be unique: {repr(bins)}.\\n\"\n- f\"You can drop duplicate edges by setting the 'duplicates' kwarg\"\n- )\n- else:\n- bins = unique_bins\n-\n- side: Literal[\"left\", \"right\"] = \"left\" if right else \"right\"\n- ids = ensure_platform_int(bins.searchsorted(x, side=side))\n-\n- if include_lowest:\n- ids[np.asarray(x) == bins[0]] = 1\n-\n- na_mask = isna(x) | (ids == len(bins)) | (ids == 0)\n- has_nas = na_mask.any()\n-\n- if labels is not False:\n- if not (labels is None or is_list_like(labels)):\n- raise ValueError(\n- \"Bin labels must either be False, None or passed in as a \"\n- \"list-like argument\"\n- )\n-\n- elif labels is None:\n- labels = _format_labels(\n- bins, precision, right=right, include_lowest=include_lowest, dtype=dtype\n- )\n- elif ordered and len(set(labels)) != len(labels):\n- raise ValueError(\n- \"labels must be unique if ordered=True; pass ordered=False \"\n- \"for duplicate labels\"\n- )\n- else:\n- if len(labels) != len(bins) - 1:\n- raise ValueError(\n- \"Bin labels must be one fewer than the number of bin edges\"\n- )\n- if not is_categorical_dtype(labels):\n- labels = Categorical(\n- labels,\n- categories=labels if len(set(labels)) == len(labels) else None,\n- ordered=ordered,\n- )\n- # TODO: handle mismatch between categorical label order and pandas.cut order.\n- np.putmask(ids, na_mask, 0)\n- result = algos.take_nd(labels, ids - 1)\n-\n- else:\n- result = ids - 1\n- if has_nas:\n- result = result.astype(np.float64)\n- np.putmask(result, na_mask, np.nan)\n-\n- return result, bins\n-\n-\n-def _coerce_to_type(x):\n- \"\"\"\n- if the passed data is of datetime/timedelta, bool or nullable int type,\n- this method converts it to numeric so that cut or qcut method can\n- handle it\n- \"\"\"\n- dtype = None\n-\n- if is_datetime64tz_dtype(x.dtype):\n- dtype = x.dtype\n- elif is_datetime64_dtype(x.dtype):\n- x = to_datetime(x)\n- dtype = np.dtype(\"datetime64[ns]\")\n- elif is_timedelta64_dtype(x.dtype):\n- x = to_timedelta(x)\n- dtype = np.dtype(\"timedelta64[ns]\")\n- elif is_bool_dtype(x.dtype):\n- # GH 20303\n- x = x.astype(np.int64)\n- # To support cut and qcut for IntegerArray we convert to float dtype.\n- # Will properly support in the future.\n- # https://github.com/pandas-dev/pandas/pull/31290\n- # https://github.com/pandas-dev/pandas/issues/31389\n- elif is_extension_array_dtype(x.dtype) and is_numeric_dtype(x.dtype):\n- x = x.to_numpy(dtype=np.float64, na_value=np.nan)\n-\n- if dtype is not None:\n- # GH 19768: force NaT to NaN during integer conversion\n- x = np.where(x.notna(), x.view(np.int64), np.nan)\n-\n- return x, dtype\n-\n-\n-def _convert_bin_to_numeric_type(bins, dtype):\n- \"\"\"\n- if the passed bin is of datetime/timedelta type,\n- this method converts it to integer\n-\n- Parameters\n- ----------\n- bins : list-like of bins\n- dtype : dtype of data\n-\n- Raises\n- ------\n- ValueError if bins are not of a compat dtype to dtype\n- \"\"\"\n- bins_dtype = infer_dtype(bins, skipna=False)\n- if is_timedelta64_dtype(dtype):\n- if bins_dtype in [\"timedelta\", \"timedelta64\"]:\n- bins = to_timedelta(bins).view(np.int64)\n- else:\n- raise ValueError(\"bins must be of timedelta64 dtype\")\n- elif is_datetime64_dtype(dtype) or is_datetime64tz_dtype(dtype):\n- if bins_dtype in [\"datetime\", \"datetime64\"]:\n- bins = to_datetime(bins).view(np.int64)\n- else:\n- raise ValueError(\"bins must be of datetime64 dtype\")\n-\n- return bins\n-\n-\n-def _convert_bin_to_datelike_type(bins, dtype):\n- \"\"\"\n- Convert bins to a DatetimeIndex or TimedeltaIndex if the original dtype is\n- datelike\n-\n- Parameters\n- ----------\n- bins : list-like of bins\n- dtype : dtype of data\n-\n- Returns\n- -------\n- bins : Array-like of bins, DatetimeIndex or TimedeltaIndex if dtype is\n- datelike\n- \"\"\"\n- if is_datetime64tz_dtype(dtype):\n- bins = to_datetime(bins.astype(np.int64), utc=True).tz_convert(dtype.tz)\n- elif is_datetime_or_timedelta_dtype(dtype):\n- bins = Index(bins.astype(np.int64), dtype=dtype)\n- return bins\n-\n-\n-def _format_labels(\n- bins, precision: int, right: bool = True, include_lowest: bool = False, dtype=None\n-):\n- \"\"\"based on the dtype, return our labels\"\"\"\n- inclusive: IntervalLeftRight = \"right\" if right else \"left\"\n-\n- formatter: Callable[[Any], Timestamp] | Callable[[Any], Timedelta]\n-\n- if is_datetime64tz_dtype(dtype):\n- formatter = lambda x: Timestamp(x, tz=dtype.tz)\n- adjust = lambda x: x - Timedelta(\"1ns\")\n- elif is_datetime64_dtype(dtype):\n- formatter = Timestamp\n- adjust = lambda x: x - Timedelta(\"1ns\")\n- elif is_timedelta64_dtype(dtype):\n- formatter = Timedelta\n- adjust = lambda x: x - Timedelta(\"1ns\")\n- else:\n- precision = _infer_precision(precision, bins)\n- formatter = lambda x: _round_frac(x, precision)\n- adjust = lambda x: x - 10 ** (-precision)\n-\n- breaks = [formatter(b) for b in bins]\n- if right and include_lowest:\n- # adjust lhs of first interval by precision to account for being right closed\n- breaks[0] = adjust(breaks[0])\n-\n- return IntervalIndex.from_breaks(breaks, inclusive=inclusive)\n-\n-\n-def _preprocess_for_cut(x):\n- \"\"\"\n- handles preprocessing for cut where we convert passed\n- input to array, strip the index information and store it\n- separately\n- \"\"\"\n- # Check that the passed array is a Pandas or Numpy object\n- # We don't want to strip away a Pandas data-type here (e.g. datetimetz)\n- ndim = getattr(x, \"ndim\", None)\n- if ndim is None:\n- x = np.asarray(x)\n- if x.ndim != 1:\n- raise ValueError(\"Input array must be 1 dimensional\")\n-\n- return x\n-\n-\n-def _postprocess_for_cut(fac, bins, retbins: bool, dtype, original):\n- \"\"\"\n- handles post processing for the cut method where\n- we combine the index information if the originally passed\n- datatype was a series\n- \"\"\"\n- if isinstance(original, ABCSeries):\n- fac = original._constructor(fac, index=original.index, name=original.name)\n-\n- if not retbins:\n- return fac\n-\n- bins = _convert_bin_to_datelike_type(bins, dtype)\n-\n- return fac, bins\n-\n-\n-def _round_frac(x, precision: int):\n- \"\"\"\n- Round the fractional part of the given number\n- \"\"\"\n- if not np.isfinite(x) or x == 0:\n- return x\n- else:\n- frac, whole = np.modf(x)\n- if whole == 0:\n- digits = -int(np.floor(np.log10(abs(frac)))) - 1 + precision\n- else:\n- digits = precision\n- return np.around(x, digits)\n-\n-\n-def _infer_precision(base_precision: int, bins) -> int:\n- \"\"\"\n- Infer an appropriate precision for _round_frac\n- \"\"\"\n- for precision in range(base_precision, 20):\n- levels = [_round_frac(b, precision) for b in bins]\n- if algos.unique(levels).size == bins.size:\n- return precision\n- return base_precision # default\n+from pandas._core.reshape.tile import *\ndiff --git a/pandas/core/reshape/util.py b/pandas/core/reshape/util.py\nindex 9f9143f4aaa60..3d14891fbadb7 100644\n--- a/pandas/core/reshape/util.py\n+++ b/pandas/core/reshape/util.py\n@@ -1,72 +1 @@\n-import numpy as np\n-\n-from pandas._typing import NumpyIndexT\n-\n-from pandas.core.dtypes.common import is_list_like\n-\n-\n-def cartesian_product(X):\n- \"\"\"\n- Numpy version of itertools.product.\n- Sometimes faster (for large inputs)...\n-\n- Parameters\n- ----------\n- X : list-like of list-likes\n-\n- Returns\n- -------\n- product : list of ndarrays\n-\n- Examples\n- --------\n- >>> cartesian_product([list('ABC'), [1, 2]])\n- [array(['A', 'A', 'B', 'B', 'C', 'C'], dtype='<U1'), array([1, 2, 1, 2, 1, 2])]\n-\n- See Also\n- --------\n- itertools.product : Cartesian product of input iterables. Equivalent to\n- nested for-loops.\n- \"\"\"\n- msg = \"Input must be a list-like of list-likes\"\n- if not is_list_like(X):\n- raise TypeError(msg)\n- for x in X:\n- if not is_list_like(x):\n- raise TypeError(msg)\n-\n- if len(X) == 0:\n- return []\n-\n- lenX = np.fromiter((len(x) for x in X), dtype=np.intp)\n- cumprodX = np.cumproduct(lenX)\n-\n- if np.any(cumprodX < 0):\n- raise ValueError(\"Product space too large to allocate arrays!\")\n-\n- a = np.roll(cumprodX, 1)\n- a[0] = 1\n-\n- if cumprodX[-1] != 0:\n- b = cumprodX[-1] / cumprodX\n- else:\n- # if any factor is empty, the cartesian product is empty\n- b = np.zeros_like(cumprodX)\n-\n- return [tile_compat(np.repeat(x, b[i]), np.product(a[i])) for i, x in enumerate(X)]\n-\n-\n-def tile_compat(arr: NumpyIndexT, num: int) -> NumpyIndexT:\n- \"\"\"\n- Index compat for np.tile.\n-\n- Notes\n- -----\n- Does not support multi-dimensional `num`.\n- \"\"\"\n- if isinstance(arr, np.ndarray):\n- return np.tile(arr, num)\n-\n- # Otherwise we have an Index\n- taker = np.tile(np.arange(len(arr)), num)\n- return arr.take(taker)\n+from pandas._core.reshape.util import *\ndiff --git a/pandas/core/roperator.py b/pandas/core/roperator.py\nindex 15b16b6fa976a..0324dab248403 100644\n--- a/pandas/core/roperator.py\n+++ b/pandas/core/roperator.py\n@@ -1,60 +1 @@\n-\"\"\"\n-Reversed Operations not available in the stdlib operator module.\n-Defining these instead of using lambdas allows us to reference them by name.\n-\"\"\"\n-import operator\n-\n-\n-def radd(left, right):\n- return right + left\n-\n-\n-def rsub(left, right):\n- return right - left\n-\n-\n-def rmul(left, right):\n- return right * left\n-\n-\n-def rdiv(left, right):\n- return right / left\n-\n-\n-def rtruediv(left, right):\n- return right / left\n-\n-\n-def rfloordiv(left, right):\n- return right // left\n-\n-\n-def rmod(left, right):\n- # check if right is a string as % is the string\n- # formatting operation; this is a TypeError\n- # otherwise perform the op\n- if isinstance(right, str):\n- typ = type(left).__name__\n- raise TypeError(f\"{typ} cannot perform the operation mod\")\n-\n- return right % left\n-\n-\n-def rdivmod(left, right):\n- return divmod(right, left)\n-\n-\n-def rpow(left, right):\n- return right**left\n-\n-\n-def rand_(left, right):\n- return operator.and_(right, left)\n-\n-\n-def ror_(left, right):\n- return operator.or_(right, left)\n-\n-\n-def rxor(left, right):\n- return operator.xor(right, left)\n+from pandas._core.roperator import *\ndiff --git a/pandas/core/sample.py b/pandas/core/sample.py\nindex 16fca2d0ff1b4..dc0adbd1262cb 100644\n--- a/pandas/core/sample.py\n+++ b/pandas/core/sample.py\n@@ -1,152 +1 @@\n-\"\"\"\n-Module containing utilities for NDFrame.sample() and .GroupBy.sample()\n-\"\"\"\n-from __future__ import annotations\n-\n-from typing import TYPE_CHECKING\n-\n-import numpy as np\n-\n-from pandas._libs import lib\n-\n-from pandas.core.dtypes.generic import (\n- ABCDataFrame,\n- ABCSeries,\n-)\n-\n-if TYPE_CHECKING:\n- from pandas.core.generic import NDFrame\n-\n-\n-def preprocess_weights(obj: NDFrame, weights, axis: int) -> np.ndarray:\n- \"\"\"\n- Process and validate the `weights` argument to `NDFrame.sample` and\n- `.GroupBy.sample`.\n-\n- Returns `weights` as an ndarray[np.float64], validated except for normalizing\n- weights (because that must be done groupwise in groupby sampling).\n- \"\"\"\n- # If a series, align with frame\n- if isinstance(weights, ABCSeries):\n- weights = weights.reindex(obj.axes[axis])\n-\n- # Strings acceptable if a dataframe and axis = 0\n- if isinstance(weights, str):\n- if isinstance(obj, ABCDataFrame):\n- if axis == 0:\n- try:\n- weights = obj[weights]\n- except KeyError as err:\n- raise KeyError(\n- \"String passed to weights not a valid column\"\n- ) from err\n- else:\n- raise ValueError(\n- \"Strings can only be passed to \"\n- \"weights when sampling from rows on \"\n- \"a DataFrame\"\n- )\n- else:\n- raise ValueError(\n- \"Strings cannot be passed as weights when sampling from a Series.\"\n- )\n-\n- if isinstance(obj, ABCSeries):\n- func = obj._constructor\n- else:\n- func = obj._constructor_sliced\n-\n- weights = func(weights, dtype=\"float64\")._values\n-\n- if len(weights) != obj.shape[axis]:\n- raise ValueError(\"Weights and axis to be sampled must be of same length\")\n-\n- if lib.has_infs(weights):\n- raise ValueError(\"weight vector may not include `inf` values\")\n-\n- if (weights < 0).any():\n- raise ValueError(\"weight vector many not include negative values\")\n-\n- missing = np.isnan(weights)\n- if missing.any():\n- # Don't modify weights in place\n- weights = weights.copy()\n- weights[missing] = 0\n- return weights\n-\n-\n-def process_sampling_size(\n- n: int | None, frac: float | None, replace: bool\n-) -> int | None:\n- \"\"\"\n- Process and validate the `n` and `frac` arguments to `NDFrame.sample` and\n- `.GroupBy.sample`.\n-\n- Returns None if `frac` should be used (variable sampling sizes), otherwise returns\n- the constant sampling size.\n- \"\"\"\n- # If no frac or n, default to n=1.\n- if n is None and frac is None:\n- n = 1\n- elif n is not None and frac is not None:\n- raise ValueError(\"Please enter a value for `frac` OR `n`, not both\")\n- elif n is not None:\n- if n < 0:\n- raise ValueError(\n- \"A negative number of rows requested. Please provide `n` >= 0.\"\n- )\n- if n % 1 != 0:\n- raise ValueError(\"Only integers accepted as `n` values\")\n- else:\n- assert frac is not None # for mypy\n- if frac > 1 and not replace:\n- raise ValueError(\n- \"Replace has to be set to `True` when \"\n- \"upsampling the population `frac` > 1.\"\n- )\n- if frac < 0:\n- raise ValueError(\n- \"A negative number of rows requested. Please provide `frac` >= 0.\"\n- )\n-\n- return n\n-\n-\n-def sample(\n- obj_len: int,\n- size: int,\n- replace: bool,\n- weights: np.ndarray | None,\n- random_state: np.random.RandomState | np.random.Generator,\n-) -> np.ndarray:\n- \"\"\"\n- Randomly sample `size` indices in `np.arange(obj_len)`\n-\n- Parameters\n- ----------\n- obj_len : int\n- The length of the indices being considered\n- size : int\n- The number of values to choose\n- replace : bool\n- Allow or disallow sampling of the same row more than once.\n- weights : np.ndarray[np.float64] or None\n- If None, equal probability weighting, otherwise weights according\n- to the vector normalized\n- random_state: np.random.RandomState or np.random.Generator\n- State used for the random sampling\n-\n- Returns\n- -------\n- np.ndarray[np.intp]\n- \"\"\"\n- if weights is not None:\n- weight_sum = weights.sum()\n- if weight_sum != 0:\n- weights = weights / weight_sum\n- else:\n- raise ValueError(\"Invalid weights: weights sum to zero\")\n-\n- return random_state.choice(obj_len, size=size, replace=replace, p=weights).astype(\n- np.intp, copy=False\n- )\n+from pandas._core.sample import *\ndiff --git a/pandas/core/series.py b/pandas/core/series.py\nindex 6ebee74810305..5b6550bb93123 100644\n--- a/pandas/core/series.py\n+++ b/pandas/core/series.py\n@@ -1,5896 +1 @@\n-\"\"\"\n-Data structure for 1-dimensional cross-sectional and time series data\n-\"\"\"\n-from __future__ import annotations\n-\n-from textwrap import dedent\n-from typing import (\n- IO,\n- TYPE_CHECKING,\n- Any,\n- Callable,\n- Hashable,\n- Iterable,\n- Literal,\n- Sequence,\n- Union,\n- cast,\n- overload,\n-)\n-import warnings\n-import weakref\n-\n-import numpy as np\n-\n-from pandas._config import get_option\n-\n-from pandas._libs import (\n- lib,\n- properties,\n- reshape,\n- tslibs,\n-)\n-from pandas._libs.lib import no_default\n-from pandas._typing import (\n- AggFuncType,\n- AnyArrayLike,\n- ArrayLike,\n- Axis,\n- Dtype,\n- DtypeObj,\n- FillnaOptions,\n- IgnoreRaise,\n- IndexKeyFunc,\n- Level,\n- NaPosition,\n- QuantileInterpolation,\n- Renamer,\n- SingleManager,\n- SortKind,\n- StorageOptions,\n- TimedeltaConvertibleTypes,\n- TimestampConvertibleTypes,\n- ValueKeyFunc,\n- npt,\n-)\n-from pandas.compat.numpy import function as nv\n-from pandas.errors import InvalidIndexError\n-from pandas.util._decorators import (\n- Appender,\n- Substitution,\n- deprecate_nonkeyword_arguments,\n- doc,\n-)\n-from pandas.util._exceptions import find_stack_level\n-from pandas.util._validators import (\n- validate_ascending,\n- validate_bool_kwarg,\n- validate_percentile,\n-)\n-\n-from pandas.core.dtypes.cast import (\n- LossySetitemError,\n- convert_dtypes,\n- maybe_box_native,\n- maybe_cast_pointwise_result,\n-)\n-from pandas.core.dtypes.common import (\n- ensure_platform_int,\n- is_dict_like,\n- is_integer,\n- is_iterator,\n- is_list_like,\n- is_object_dtype,\n- is_scalar,\n- pandas_dtype,\n- validate_all_hashable,\n-)\n-from pandas.core.dtypes.generic import ABCDataFrame\n-from pandas.core.dtypes.inference import is_hashable\n-from pandas.core.dtypes.missing import (\n- isna,\n- na_value_for_dtype,\n- notna,\n- remove_na_arraylike,\n-)\n-\n-from pandas.core import (\n- algorithms,\n- base,\n- common as com,\n- missing,\n- nanops,\n- ops,\n-)\n-from pandas.core.accessor import CachedAccessor\n-from pandas.core.apply import SeriesApply\n-from pandas.core.arrays import ExtensionArray\n-from pandas.core.arrays.categorical import CategoricalAccessor\n-from pandas.core.arrays.sparse import SparseAccessor\n-from pandas.core.construction import (\n- create_series_with_explicit_dtype,\n- extract_array,\n- is_empty_data,\n- sanitize_array,\n-)\n-from pandas.core.generic import NDFrame\n-from pandas.core.indexers import (\n- deprecate_ndim_indexing,\n- unpack_1tuple,\n-)\n-from pandas.core.indexes.accessors import CombinedDatetimelikeProperties\n-from pandas.core.indexes.api import (\n- CategoricalIndex,\n- DatetimeIndex,\n- Float64Index,\n- Index,\n- MultiIndex,\n- PeriodIndex,\n- TimedeltaIndex,\n- default_index,\n- ensure_index,\n-)\n-import pandas.core.indexes.base as ibase\n-from pandas.core.indexing import (\n- check_bool_indexer,\n- check_deprecated_indexers,\n-)\n-from pandas.core.internals import (\n- SingleArrayManager,\n- SingleBlockManager,\n-)\n-from pandas.core.shared_docs import _shared_docs\n-from pandas.core.sorting import (\n- ensure_key_mapped,\n- nargsort,\n-)\n-from pandas.core.strings import StringMethods\n-from pandas.core.tools.datetimes import to_datetime\n-\n-import pandas.io.formats.format as fmt\n-from pandas.io.formats.info import (\n- INFO_DOCSTRING,\n- SeriesInfo,\n- series_sub_kwargs,\n-)\n-import pandas.plotting\n-\n-if TYPE_CHECKING:\n-\n- from pandas._typing import (\n- NumpySorter,\n- NumpyValueArrayLike,\n- )\n-\n- from pandas.core.frame import DataFrame\n- from pandas.core.groupby.generic import SeriesGroupBy\n- from pandas.core.resample import Resampler\n-\n-__all__ = [\"Series\"]\n-\n-_shared_doc_kwargs = {\n- \"axes\": \"index\",\n- \"klass\": \"Series\",\n- \"axes_single_arg\": \"{0 or 'index'}\",\n- \"axis\": \"\"\"axis : {0 or 'index'}\n- Unused. Parameter needed for compatibility with DataFrame.\"\"\",\n- \"inplace\": \"\"\"inplace : bool, default False\n- If True, performs operation inplace and returns None.\"\"\",\n- \"unique\": \"np.ndarray\",\n- \"duplicated\": \"Series\",\n- \"optional_by\": \"\",\n- \"optional_mapper\": \"\",\n- \"optional_labels\": \"\",\n- \"optional_axis\": \"\",\n- \"replace_iloc\": \"\"\"\n- This differs from updating with ``.loc`` or ``.iloc``, which require\n- you to specify a location to update with some value.\"\"\",\n-}\n-\n-\n-def _coerce_method(converter):\n- \"\"\"\n- Install the scalar coercion methods.\n- \"\"\"\n-\n- def wrapper(self):\n- if len(self) == 1:\n- return converter(self.iloc[0])\n- raise TypeError(f\"cannot convert the series to {converter}\")\n-\n- wrapper.__name__ = f\"__{converter.__name__}__\"\n- return wrapper\n-\n-\n-# ----------------------------------------------------------------------\n-# Series class\n-\n-\n-class Series(base.IndexOpsMixin, NDFrame):\n- \"\"\"\n- One-dimensional ndarray with axis labels (including time series).\n-\n- Labels need not be unique but must be a hashable type. The object\n- supports both integer- and label-based indexing and provides a host of\n- methods for performing operations involving the index. Statistical\n- methods from ndarray have been overridden to automatically exclude\n- missing data (currently represented as NaN).\n-\n- Operations between Series (+, -, /, \\\\*, \\\\*\\\\*) align values based on their\n- associated index values-- they need not be the same length. The result\n- index will be the sorted union of the two indexes.\n-\n- Parameters\n- ----------\n- data : array-like, Iterable, dict, or scalar value\n- Contains data stored in Series. If data is a dict, argument order is\n- maintained.\n- index : array-like or Index (1d)\n- Values must be hashable and have the same length as `data`.\n- Non-unique index values are allowed. Will default to\n- RangeIndex (0, 1, 2, ..., n) if not provided. If data is dict-like\n- and index is None, then the keys in the data are used as the index. If the\n- index is not None, the resulting Series is reindexed with the index values.\n- dtype : str, numpy.dtype, or ExtensionDtype, optional\n- Data type for the output Series. If not specified, this will be\n- inferred from `data`.\n- See the :ref:`user guide <basics.dtypes>` for more usages.\n- name : str, optional\n- The name to give to the Series.\n- copy : bool, default False\n- Copy input data. Only affects Series or 1d ndarray input. See examples.\n-\n- Notes\n- -----\n- Please reference the :ref:`User Guide <basics.series>` for more information.\n-\n- Examples\n- --------\n- Constructing Series from a dictionary with an Index specified\n-\n- >>> d = {'a': 1, 'b': 2, 'c': 3}\n- >>> ser = pd.Series(data=d, index=['a', 'b', 'c'])\n- >>> ser\n- a 1\n- b 2\n- c 3\n- dtype: int64\n-\n- The keys of the dictionary match with the Index values, hence the Index\n- values have no effect.\n-\n- >>> d = {'a': 1, 'b': 2, 'c': 3}\n- >>> ser = pd.Series(data=d, index=['x', 'y', 'z'])\n- >>> ser\n- x NaN\n- y NaN\n- z NaN\n- dtype: float64\n-\n- Note that the Index is first build with the keys from the dictionary.\n- After this the Series is reindexed with the given Index values, hence we\n- get all NaN as a result.\n-\n- Constructing Series from a list with `copy=False`.\n-\n- >>> r = [1, 2]\n- >>> ser = pd.Series(r, copy=False)\n- >>> ser.iloc[0] = 999\n- >>> r\n- [1, 2]\n- >>> ser\n- 0 999\n- 1 2\n- dtype: int64\n-\n- Due to input data type the Series has a `copy` of\n- the original data even though `copy=False`, so\n- the data is unchanged.\n-\n- Constructing Series from a 1d ndarray with `copy=False`.\n-\n- >>> r = np.array([1, 2])\n- >>> ser = pd.Series(r, copy=False)\n- >>> ser.iloc[0] = 999\n- >>> r\n- array([999, 2])\n- >>> ser\n- 0 999\n- 1 2\n- dtype: int64\n-\n- Due to input data type the Series has a `view` on\n- the original data, so\n- the data is changed as well.\n- \"\"\"\n-\n- _typ = \"series\"\n- _HANDLED_TYPES = (Index, ExtensionArray, np.ndarray)\n-\n- _name: Hashable\n- _metadata: list[str] = [\"name\"]\n- _internal_names_set = {\"index\"} | NDFrame._internal_names_set\n- _accessors = {\"dt\", \"cat\", \"str\", \"sparse\"}\n- _hidden_attrs = (\n- base.IndexOpsMixin._hidden_attrs\n- | NDFrame._hidden_attrs\n- | frozenset([\"compress\", \"ptp\"])\n- )\n-\n- # Override cache_readonly bc Series is mutable\n- # error: Incompatible types in assignment (expression has type \"property\",\n- # base class \"IndexOpsMixin\" defined the type as \"Callable[[IndexOpsMixin], bool]\")\n- hasnans = property( # type: ignore[assignment]\n- # error: \"Callable[[IndexOpsMixin], bool]\" has no attribute \"fget\"\n- base.IndexOpsMixin.hasnans.fget, # type: ignore[attr-defined]\n- doc=base.IndexOpsMixin.hasnans.__doc__,\n- )\n- _mgr: SingleManager\n- div: Callable[[Series, Any], Series]\n- rdiv: Callable[[Series, Any], Series]\n-\n- # ----------------------------------------------------------------------\n- # Constructors\n-\n- def __init__(\n- self,\n- data=None,\n- index=None,\n- dtype: Dtype | None = None,\n- name=None,\n- copy: bool = False,\n- fastpath: bool = False,\n- ) -> None:\n-\n- if (\n- isinstance(data, (SingleBlockManager, SingleArrayManager))\n- and index is None\n- and dtype is None\n- and copy is False\n- ):\n- # GH#33357 called with just the SingleBlockManager\n- NDFrame.__init__(self, data)\n- if fastpath:\n- # e.g. from _box_col_values, skip validation of name\n- object.__setattr__(self, \"_name\", name)\n- else:\n- self.name = name\n- return\n-\n- # we are called internally, so short-circuit\n- if fastpath:\n-\n- # data is an ndarray, index is defined\n- if not isinstance(data, (SingleBlockManager, SingleArrayManager)):\n- manager = get_option(\"mode.data_manager\")\n- if manager == \"block\":\n- data = SingleBlockManager.from_array(data, index)\n- elif manager == \"array\":\n- data = SingleArrayManager.from_array(data, index)\n- if copy:\n- data = data.copy()\n- if index is None:\n- index = data.index\n-\n- else:\n-\n- name = ibase.maybe_extract_name(name, data, type(self))\n-\n- if is_empty_data(data) and dtype is None:\n- # gh-17261\n- warnings.warn(\n- \"The default dtype for empty Series will be 'object' instead \"\n- \"of 'float64' in a future version. Specify a dtype explicitly \"\n- \"to silence this warning.\",\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n- # uncomment the line below when removing the FutureWarning\n- # dtype = np.dtype(object)\n-\n- if index is not None:\n- index = ensure_index(index)\n-\n- if data is None:\n- data = {}\n- if dtype is not None:\n- dtype = self._validate_dtype(dtype)\n-\n- if isinstance(data, MultiIndex):\n- raise NotImplementedError(\n- \"initializing a Series from a MultiIndex is not supported\"\n- )\n- elif isinstance(data, Index):\n-\n- if dtype is not None:\n- # astype copies\n- data = data.astype(dtype)\n- else:\n- # GH#24096 we need to ensure the index remains immutable\n- data = data._values.copy()\n- copy = False\n-\n- elif isinstance(data, np.ndarray):\n- if len(data.dtype):\n- # GH#13296 we are dealing with a compound dtype, which\n- # should be treated as 2D\n- raise ValueError(\n- \"Cannot construct a Series from an ndarray with \"\n- \"compound dtype. Use DataFrame instead.\"\n- )\n- elif isinstance(data, Series):\n- if index is None:\n- index = data.index\n- else:\n- data = data.reindex(index, copy=copy)\n- copy = False\n- data = data._mgr\n- elif is_dict_like(data):\n- data, index = self._init_dict(data, index, dtype)\n- dtype = None\n- copy = False\n- elif isinstance(data, (SingleBlockManager, SingleArrayManager)):\n- if index is None:\n- index = data.index\n- elif not data.index.equals(index) or copy:\n- # GH#19275 SingleBlockManager input should only be called\n- # internally\n- raise AssertionError(\n- \"Cannot pass both SingleBlockManager \"\n- \"`data` argument and a different \"\n- \"`index` argument. `copy` must be False.\"\n- )\n-\n- elif isinstance(data, ExtensionArray):\n- pass\n- else:\n- data = com.maybe_iterable_to_list(data)\n-\n- if index is None:\n- if not is_list_like(data):\n- data = [data]\n- index = default_index(len(data))\n- elif is_list_like(data):\n- com.require_length_match(data, index)\n-\n- # create/copy the manager\n- if isinstance(data, (SingleBlockManager, SingleArrayManager)):\n- if dtype is not None:\n- data = data.astype(dtype=dtype, errors=\"ignore\", copy=copy)\n- elif copy:\n- data = data.copy()\n- else:\n- data = sanitize_array(data, index, dtype, copy)\n-\n- manager = get_option(\"mode.data_manager\")\n- if manager == \"block\":\n- data = SingleBlockManager.from_array(data, index)\n- elif manager == \"array\":\n- data = SingleArrayManager.from_array(data, index)\n-\n- NDFrame.__init__(self, data)\n- if fastpath:\n- # skips validation of the name\n- object.__setattr__(self, \"_name\", name)\n- else:\n- self.name = name\n- self._set_axis(0, index)\n-\n- def _init_dict(\n- self, data, index: Index | None = None, dtype: DtypeObj | None = None\n- ):\n- \"\"\"\n- Derive the \"_mgr\" and \"index\" attributes of a new Series from a\n- dictionary input.\n-\n- Parameters\n- ----------\n- data : dict or dict-like\n- Data used to populate the new Series.\n- index : Index or None, default None\n- Index for the new Series: if None, use dict keys.\n- dtype : np.dtype, ExtensionDtype, or None, default None\n- The dtype for the new Series: if None, infer from data.\n-\n- Returns\n- -------\n- _data : BlockManager for the new Series\n- index : index for the new Series\n- \"\"\"\n- keys: Index | tuple\n-\n- # Looking for NaN in dict doesn't work ({np.nan : 1}[float('nan')]\n- # raises KeyError), so we iterate the entire dict, and align\n- if data:\n- # GH:34717, issue was using zip to extract key and values from data.\n- # using generators in effects the performance.\n- # Below is the new way of extracting the keys and values\n-\n- keys = tuple(data.keys())\n- values = list(data.values()) # Generating list of values- faster way\n- elif index is not None:\n- # fastpath for Series(data=None). Just use broadcasting a scalar\n- # instead of reindexing.\n- values = na_value_for_dtype(pandas_dtype(dtype), compat=False)\n- keys = index\n- else:\n- keys, values = (), []\n-\n- # Input is now list-like, so rely on \"standard\" construction:\n-\n- # TODO: passing np.float64 to not break anything yet. See GH-17261\n- s = create_series_with_explicit_dtype(\n- # error: Argument \"index\" to \"create_series_with_explicit_dtype\" has\n- # incompatible type \"Tuple[Any, ...]\"; expected \"Union[ExtensionArray,\n- # ndarray, Index, None]\"\n- values,\n- index=keys, # type: ignore[arg-type]\n- dtype=dtype,\n- dtype_if_empty=np.float64,\n- )\n-\n- # Now we just make sure the order is respected, if any\n- if data and index is not None:\n- s = s.reindex(index, copy=False)\n- return s._mgr, s.index\n-\n- # ----------------------------------------------------------------------\n-\n- @property\n- def _constructor(self) -> Callable[..., Series]:\n- return Series\n-\n- @property\n- def _constructor_expanddim(self) -> Callable[..., DataFrame]:\n- \"\"\"\n- Used when a manipulation result has one higher dimension as the\n- original, such as Series.to_frame()\n- \"\"\"\n- from pandas.core.frame import DataFrame\n-\n- return DataFrame\n-\n- # types\n- @property\n- def _can_hold_na(self) -> bool:\n- return self._mgr._can_hold_na\n-\n- def _set_axis(self, axis: int, labels: AnyArrayLike | Sequence) -> None:\n- \"\"\"\n- Override generic, we want to set the _typ here.\n-\n- This is called from the cython code when we set the `index` attribute\n- directly, e.g. `series.index = [1, 2, 3]`.\n- \"\"\"\n- labels = ensure_index(labels)\n-\n- if labels._is_all_dates:\n- deep_labels = labels\n- if isinstance(labels, CategoricalIndex):\n- deep_labels = labels.categories\n-\n- if not isinstance(\n- deep_labels, (DatetimeIndex, PeriodIndex, TimedeltaIndex)\n- ):\n- try:\n- labels = DatetimeIndex(labels)\n- except (tslibs.OutOfBoundsDatetime, ValueError):\n- # labels may exceeds datetime bounds,\n- # or not be a DatetimeIndex\n- pass\n-\n- # The ensure_index call above ensures we have an Index object\n- self._mgr.set_axis(axis, labels)\n-\n- # ndarray compatibility\n- @property\n- def dtype(self) -> DtypeObj:\n- \"\"\"\n- Return the dtype object of the underlying data.\n- \"\"\"\n- return self._mgr.dtype\n-\n- @property\n- def dtypes(self) -> DtypeObj:\n- \"\"\"\n- Return the dtype object of the underlying data.\n- \"\"\"\n- # DataFrame compatibility\n- return self.dtype\n-\n- @property\n- def name(self) -> Hashable:\n- \"\"\"\n- Return the name of the Series.\n-\n- The name of a Series becomes its index or column name if it is used\n- to form a DataFrame. It is also used whenever displaying the Series\n- using the interpreter.\n-\n- Returns\n- -------\n- label (hashable object)\n- The name of the Series, also the column name if part of a DataFrame.\n-\n- See Also\n- --------\n- Series.rename : Sets the Series name when given a scalar input.\n- Index.name : Corresponding Index property.\n-\n- Examples\n- --------\n- The Series name can be set initially when calling the constructor.\n-\n- >>> s = pd.Series([1, 2, 3], dtype=np.int64, name='Numbers')\n- >>> s\n- 0 1\n- 1 2\n- 2 3\n- Name: Numbers, dtype: int64\n- >>> s.name = \"Integers\"\n- >>> s\n- 0 1\n- 1 2\n- 2 3\n- Name: Integers, dtype: int64\n-\n- The name of a Series within a DataFrame is its column name.\n-\n- >>> df = pd.DataFrame([[1, 2], [3, 4], [5, 6]],\n- ... columns=[\"Odd Numbers\", \"Even Numbers\"])\n- >>> df\n- Odd Numbers Even Numbers\n- 0 1 2\n- 1 3 4\n- 2 5 6\n- >>> df[\"Even Numbers\"].name\n- 'Even Numbers'\n- \"\"\"\n- return self._name\n-\n- @name.setter\n- def name(self, value: Hashable) -> None:\n- validate_all_hashable(value, error_name=f\"{type(self).__name__}.name\")\n- object.__setattr__(self, \"_name\", value)\n-\n- @property\n- def values(self):\n- \"\"\"\n- Return Series as ndarray or ndarray-like depending on the dtype.\n-\n- .. warning::\n-\n- We recommend using :attr:`Series.array` or\n- :meth:`Series.to_numpy`, depending on whether you need\n- a reference to the underlying data or a NumPy array.\n-\n- Returns\n- -------\n- numpy.ndarray or ndarray-like\n-\n- See Also\n- --------\n- Series.array : Reference to the underlying data.\n- Series.to_numpy : A NumPy array representing the underlying data.\n-\n- Examples\n- --------\n- >>> pd.Series([1, 2, 3]).values\n- array([1, 2, 3])\n-\n- >>> pd.Series(list('aabc')).values\n- array(['a', 'a', 'b', 'c'], dtype=object)\n-\n- >>> pd.Series(list('aabc')).astype('category').values\n- ['a', 'a', 'b', 'c']\n- Categories (3, object): ['a', 'b', 'c']\n-\n- Timezone aware datetime data is converted to UTC:\n-\n- >>> pd.Series(pd.date_range('20130101', periods=3,\n- ... tz='US/Eastern')).values\n- array(['2013-01-01T05:00:00.000000000',\n- '2013-01-02T05:00:00.000000000',\n- '2013-01-03T05:00:00.000000000'], dtype='datetime64[ns]')\n- \"\"\"\n- return self._mgr.external_values()\n-\n- @property\n- def _values(self):\n- \"\"\"\n- Return the internal repr of this data (defined by Block.interval_values).\n- This are the values as stored in the Block (ndarray or ExtensionArray\n- depending on the Block class), with datetime64[ns] and timedelta64[ns]\n- wrapped in ExtensionArrays to match Index._values behavior.\n-\n- Differs from the public ``.values`` for certain data types, because of\n- historical backwards compatibility of the public attribute (e.g. period\n- returns object ndarray and datetimetz a datetime64[ns] ndarray for\n- ``.values`` while it returns an ExtensionArray for ``._values`` in those\n- cases).\n-\n- Differs from ``.array`` in that this still returns the numpy array if\n- the Block is backed by a numpy array (except for datetime64 and\n- timedelta64 dtypes), while ``.array`` ensures to always return an\n- ExtensionArray.\n-\n- Overview:\n-\n- dtype | values | _values | array |\n- ----------- | ------------- | ------------- | ------------- |\n- Numeric | ndarray | ndarray | PandasArray |\n- Category | Categorical | Categorical | Categorical |\n- dt64[ns] | ndarray[M8ns] | DatetimeArray | DatetimeArray |\n- dt64[ns tz] | ndarray[M8ns] | DatetimeArray | DatetimeArray |\n- td64[ns] | ndarray[m8ns] | TimedeltaArray| ndarray[m8ns] |\n- Period | ndarray[obj] | PeriodArray | PeriodArray |\n- Nullable | EA | EA | EA |\n-\n- \"\"\"\n- return self._mgr.internal_values()\n-\n- # error: Decorated property not supported\n- @Appender(base.IndexOpsMixin.array.__doc__) # type: ignore[misc]\n- @property\n- def array(self) -> ExtensionArray:\n- return self._mgr.array_values()\n-\n- # ops\n- def ravel(self, order=\"C\"):\n- \"\"\"\n- Return the flattened underlying data as an ndarray.\n-\n- Returns\n- -------\n- numpy.ndarray or ndarray-like\n- Flattened data of the Series.\n-\n- See Also\n- --------\n- numpy.ndarray.ravel : Return a flattened array.\n- \"\"\"\n- return self._values.ravel(order=order)\n-\n- def __len__(self) -> int:\n- \"\"\"\n- Return the length of the Series.\n- \"\"\"\n- return len(self._mgr)\n-\n- def view(self, dtype: Dtype | None = None) -> Series:\n- \"\"\"\n- Create a new view of the Series.\n-\n- This function will return a new Series with a view of the same\n- underlying values in memory, optionally reinterpreted with a new data\n- type. The new data type must preserve the same size in bytes as to not\n- cause index misalignment.\n-\n- Parameters\n- ----------\n- dtype : data type\n- Data type object or one of their string representations.\n-\n- Returns\n- -------\n- Series\n- A new Series object as a view of the same data in memory.\n-\n- See Also\n- --------\n- numpy.ndarray.view : Equivalent numpy function to create a new view of\n- the same data in memory.\n-\n- Notes\n- -----\n- Series are instantiated with ``dtype=float64`` by default. While\n- ``numpy.ndarray.view()`` will return a view with the same data type as\n- the original array, ``Series.view()`` (without specified dtype)\n- will try using ``float64`` and may fail if the original data type size\n- in bytes is not the same.\n-\n- Examples\n- --------\n- >>> s = pd.Series([-2, -1, 0, 1, 2], dtype='int8')\n- >>> s\n- 0 -2\n- 1 -1\n- 2 0\n- 3 1\n- 4 2\n- dtype: int8\n-\n- The 8 bit signed integer representation of `-1` is `0b11111111`, but\n- the same bytes represent 255 if read as an 8 bit unsigned integer:\n-\n- >>> us = s.view('uint8')\n- >>> us\n- 0 254\n- 1 255\n- 2 0\n- 3 1\n- 4 2\n- dtype: uint8\n-\n- The views share the same underlying values:\n-\n- >>> us[0] = 128\n- >>> s\n- 0 -128\n- 1 -1\n- 2 0\n- 3 1\n- 4 2\n- dtype: int8\n- \"\"\"\n- # self.array instead of self._values so we piggyback on PandasArray\n- # implementation\n- res_values = self.array.view(dtype)\n- res_ser = self._constructor(res_values, index=self.index)\n- return res_ser.__finalize__(self, method=\"view\")\n-\n- # ----------------------------------------------------------------------\n- # NDArray Compat\n- _HANDLED_TYPES = (Index, ExtensionArray, np.ndarray)\n-\n- def __array__(self, dtype: npt.DTypeLike | None = None) -> np.ndarray:\n- \"\"\"\n- Return the values as a NumPy array.\n-\n- Users should not call this directly. Rather, it is invoked by\n- :func:`numpy.array` and :func:`numpy.asarray`.\n-\n- Parameters\n- ----------\n- dtype : str or numpy.dtype, optional\n- The dtype to use for the resulting NumPy array. By default,\n- the dtype is inferred from the data.\n-\n- Returns\n- -------\n- numpy.ndarray\n- The values in the series converted to a :class:`numpy.ndarray`\n- with the specified `dtype`.\n-\n- See Also\n- --------\n- array : Create a new array from data.\n- Series.array : Zero-copy view to the array backing the Series.\n- Series.to_numpy : Series method for similar behavior.\n-\n- Examples\n- --------\n- >>> ser = pd.Series([1, 2, 3])\n- >>> np.asarray(ser)\n- array([1, 2, 3])\n-\n- For timezone-aware data, the timezones may be retained with\n- ``dtype='object'``\n-\n- >>> tzser = pd.Series(pd.date_range('2000', periods=2, tz=\"CET\"))\n- >>> np.asarray(tzser, dtype=\"object\")\n- array([Timestamp('2000-01-01 00:00:00+0100', tz='CET'),\n- Timestamp('2000-01-02 00:00:00+0100', tz='CET')],\n- dtype=object)\n-\n- Or the values may be localized to UTC and the tzinfo discarded with\n- ``dtype='datetime64[ns]'``\n-\n- >>> np.asarray(tzser, dtype=\"datetime64[ns]\") # doctest: +ELLIPSIS\n- array(['1999-12-31T23:00:00.000000000', ...],\n- dtype='datetime64[ns]')\n- \"\"\"\n- return np.asarray(self._values, dtype)\n-\n- # ----------------------------------------------------------------------\n- # Unary Methods\n-\n- # coercion\n- __float__ = _coerce_method(float)\n- __long__ = _coerce_method(int)\n- __int__ = _coerce_method(int)\n-\n- # ----------------------------------------------------------------------\n-\n- # indexers\n- @property\n- def axes(self) -> list[Index]:\n- \"\"\"\n- Return a list of the row axis labels.\n- \"\"\"\n- return [self.index]\n-\n- # ----------------------------------------------------------------------\n- # Indexing Methods\n-\n- @Appender(NDFrame.take.__doc__)\n- def take(self, indices, axis=0, is_copy=None, **kwargs) -> Series:\n- if is_copy is not None:\n- warnings.warn(\n- \"is_copy is deprecated and will be removed in a future version. \"\n- \"'take' always returns a copy, so there is no need to specify this.\",\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n- nv.validate_take((), kwargs)\n-\n- indices = ensure_platform_int(indices)\n- new_index = self.index.take(indices)\n- new_values = self._values.take(indices)\n-\n- result = self._constructor(new_values, index=new_index, fastpath=True)\n- return result.__finalize__(self, method=\"take\")\n-\n- def _take_with_is_copy(self, indices, axis=0) -> Series:\n- \"\"\"\n- Internal version of the `take` method that sets the `_is_copy`\n- attribute to keep track of the parent dataframe (using in indexing\n- for the SettingWithCopyWarning). For Series this does the same\n- as the public take (it never sets `_is_copy`).\n-\n- See the docstring of `take` for full explanation of the parameters.\n- \"\"\"\n- return self.take(indices=indices, axis=axis)\n-\n- def _ixs(self, i: int, axis: int = 0):\n- \"\"\"\n- Return the i-th value or values in the Series by location.\n-\n- Parameters\n- ----------\n- i : int\n-\n- Returns\n- -------\n- scalar (int) or Series (slice, sequence)\n- \"\"\"\n- return self._values[i]\n-\n- def _slice(self, slobj: slice, axis: int = 0) -> Series:\n- # axis kwarg is retained for compat with NDFrame method\n- # _slice is *always* positional\n- return self._get_values(slobj)\n-\n- def __getitem__(self, key):\n- check_deprecated_indexers(key)\n- key = com.apply_if_callable(key, self)\n-\n- if key is Ellipsis:\n- return self\n-\n- key_is_scalar = is_scalar(key)\n- if isinstance(key, (list, tuple)):\n- key = unpack_1tuple(key)\n-\n- if is_integer(key) and self.index._should_fallback_to_positional:\n- return self._values[key]\n-\n- elif key_is_scalar:\n- return self._get_value(key)\n-\n- if is_hashable(key):\n- # Otherwise index.get_value will raise InvalidIndexError\n- try:\n- # For labels that don't resolve as scalars like tuples and frozensets\n- result = self._get_value(key)\n-\n- return result\n-\n- except (KeyError, TypeError, InvalidIndexError):\n- # InvalidIndexError for e.g. generator\n- # see test_series_getitem_corner_generator\n- if isinstance(key, tuple) and isinstance(self.index, MultiIndex):\n- # We still have the corner case where a tuple is a key\n- # in the first level of our MultiIndex\n- return self._get_values_tuple(key)\n-\n- if is_iterator(key):\n- key = list(key)\n-\n- if com.is_bool_indexer(key):\n- key = check_bool_indexer(self.index, key)\n- key = np.asarray(key, dtype=bool)\n- return self._get_values(key)\n-\n- return self._get_with(key)\n-\n- def _get_with(self, key):\n- # other: fancy integer or otherwise\n- if isinstance(key, slice):\n- # _convert_slice_indexer to determine if this slice is positional\n- # or label based, and if the latter, convert to positional\n- slobj = self.index._convert_slice_indexer(key, kind=\"getitem\")\n- return self._slice(slobj)\n- elif isinstance(key, ABCDataFrame):\n- raise TypeError(\n- \"Indexing a Series with DataFrame is not \"\n- \"supported, use the appropriate DataFrame column\"\n- )\n- elif isinstance(key, tuple):\n- return self._get_values_tuple(key)\n-\n- elif not is_list_like(key):\n- # e.g. scalars that aren't recognized by lib.is_scalar, GH#32684\n- return self.loc[key]\n-\n- if not isinstance(key, (list, np.ndarray, ExtensionArray, Series, Index)):\n- key = list(key)\n-\n- if isinstance(key, Index):\n- key_type = key.inferred_type\n- else:\n- key_type = lib.infer_dtype(key, skipna=False)\n-\n- # Note: The key_type == \"boolean\" case should be caught by the\n- # com.is_bool_indexer check in __getitem__\n- if key_type == \"integer\":\n- # We need to decide whether to treat this as a positional indexer\n- # (i.e. self.iloc) or label-based (i.e. self.loc)\n- if not self.index._should_fallback_to_positional:\n- return self.loc[key]\n- else:\n- return self.iloc[key]\n-\n- # handle the dup indexing case GH#4246\n- return self.loc[key]\n-\n- def _get_values_tuple(self, key: tuple):\n- # mpl hackaround\n- if com.any_none(*key):\n- # mpl compat if we look up e.g. ser[:, np.newaxis];\n- # see tests.series.timeseries.test_mpl_compat_hack\n- # the asarray is needed to avoid returning a 2D DatetimeArray\n- result = np.asarray(self._values[key])\n- deprecate_ndim_indexing(result, stacklevel=find_stack_level())\n- return result\n-\n- if not isinstance(self.index, MultiIndex):\n- raise KeyError(\"key of type tuple not found and not a MultiIndex\")\n-\n- # If key is contained, would have returned by now\n- indexer, new_index = self.index.get_loc_level(key)\n- return self._constructor(self._values[indexer], index=new_index).__finalize__(\n- self\n- )\n-\n- def _get_values(self, indexer: slice | npt.NDArray[np.bool_]) -> Series:\n- new_mgr = self._mgr.getitem_mgr(indexer)\n- return self._constructor(new_mgr).__finalize__(self)\n-\n- def _get_value(self, label, takeable: bool = False):\n- \"\"\"\n- Quickly retrieve single value at passed index label.\n-\n- Parameters\n- ----------\n- label : object\n- takeable : interpret the index as indexers, default False\n-\n- Returns\n- -------\n- scalar value\n- \"\"\"\n- if takeable:\n- return self._values[label]\n-\n- # Similar to Index.get_value, but we do not fall back to positional\n- loc = self.index.get_loc(label)\n- return self.index._get_values_for_loc(self, loc, label)\n-\n- def __setitem__(self, key, value) -> None:\n- check_deprecated_indexers(key)\n- key = com.apply_if_callable(key, self)\n- cacher_needs_updating = self._check_is_chained_assignment_possible()\n-\n- if key is Ellipsis:\n- key = slice(None)\n-\n- if isinstance(key, slice):\n- indexer = self.index._convert_slice_indexer(key, kind=\"getitem\")\n- return self._set_values(indexer, value)\n-\n- try:\n- self._set_with_engine(key, value)\n- except KeyError:\n- # We have a scalar (or for MultiIndex or object-dtype, scalar-like)\n- # key that is not present in self.index.\n- if is_integer(key) and self.index.inferred_type != \"integer\":\n- # positional setter\n- if not self.index._should_fallback_to_positional:\n- # GH#33469\n- warnings.warn(\n- \"Treating integers as positional in Series.__setitem__ \"\n- \"with a Float64Index is deprecated. In a future version, \"\n- \"`series[an_int] = val` will insert a new key into the \"\n- \"Series. Use `series.iloc[an_int] = val` to treat the \"\n- \"key as positional.\",\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n- # can't use _mgr.setitem_inplace yet bc could have *both*\n- # KeyError and then ValueError, xref GH#45070\n- self._set_values(key, value)\n- else:\n- # GH#12862 adding a new key to the Series\n- self.loc[key] = value\n-\n- except (TypeError, ValueError, LossySetitemError):\n- # The key was OK, but we cannot set the value losslessly\n- indexer = self.index.get_loc(key)\n- self._set_values(indexer, value)\n-\n- except InvalidIndexError as err:\n- if isinstance(key, tuple) and not isinstance(self.index, MultiIndex):\n- # cases with MultiIndex don't get here bc they raise KeyError\n- # e.g. test_basic_getitem_setitem_corner\n- raise KeyError(\n- \"key of type tuple not found and not a MultiIndex\"\n- ) from err\n-\n- if com.is_bool_indexer(key):\n- key = check_bool_indexer(self.index, key)\n- key = np.asarray(key, dtype=bool)\n-\n- if (\n- is_list_like(value)\n- and len(value) != len(self)\n- and not isinstance(value, Series)\n- and not is_object_dtype(self.dtype)\n- ):\n- # Series will be reindexed to have matching length inside\n- # _where call below\n- # GH#44265\n- indexer = key.nonzero()[0]\n- self._set_values(indexer, value)\n- return\n-\n- # otherwise with listlike other we interpret series[mask] = other\n- # as series[mask] = other[mask]\n- try:\n- self._where(~key, value, inplace=True)\n- except InvalidIndexError:\n- # test_where_dups\n- self.iloc[key] = value\n- return\n-\n- else:\n- self._set_with(key, value)\n-\n- if cacher_needs_updating:\n- self._maybe_update_cacher()\n-\n- def _set_with_engine(self, key, value) -> None:\n- loc = self.index.get_loc(key)\n-\n- # this is equivalent to self._values[key] = value\n- self._mgr.setitem_inplace(loc, value)\n-\n- def _set_with(self, key, value):\n- # We got here via exception-handling off of InvalidIndexError, so\n- # key should always be listlike at this point.\n- assert not isinstance(key, tuple)\n-\n- if is_iterator(key):\n- # Without this, the call to infer_dtype will consume the generator\n- key = list(key)\n-\n- if not self.index._should_fallback_to_positional:\n- # Regardless of the key type, we're treating it as labels\n- self._set_labels(key, value)\n-\n- else:\n- # Note: key_type == \"boolean\" should not occur because that\n- # should be caught by the is_bool_indexer check in __setitem__\n- key_type = lib.infer_dtype(key, skipna=False)\n-\n- if key_type == \"integer\":\n- self._set_values(key, value)\n- else:\n- self._set_labels(key, value)\n-\n- def _set_labels(self, key, value) -> None:\n- key = com.asarray_tuplesafe(key)\n- indexer: np.ndarray = self.index.get_indexer(key)\n- mask = indexer == -1\n- if mask.any():\n- raise KeyError(f\"{key[mask]} not in index\")\n- self._set_values(indexer, value)\n-\n- def _set_values(self, key, value) -> None:\n- if isinstance(key, (Index, Series)):\n- key = key._values\n-\n- self._mgr = self._mgr.setitem(indexer=key, value=value)\n- self._maybe_update_cacher()\n-\n- def _set_value(self, label, value, takeable: bool = False):\n- \"\"\"\n- Quickly set single value at passed label.\n-\n- If label is not contained, a new object is created with the label\n- placed at the end of the result index.\n-\n- Parameters\n- ----------\n- label : object\n- Partial indexing with MultiIndex not allowed.\n- value : object\n- Scalar value.\n- takeable : interpret the index as indexers, default False\n- \"\"\"\n- if not takeable:\n- try:\n- loc = self.index.get_loc(label)\n- except KeyError:\n- # set using a non-recursive method\n- self.loc[label] = value\n- return\n- else:\n- loc = label\n-\n- self._set_values(loc, value)\n-\n- # ----------------------------------------------------------------------\n- # Lookup Caching\n-\n- @property\n- def _is_cached(self) -> bool:\n- \"\"\"Return boolean indicating if self is cached or not.\"\"\"\n- return getattr(self, \"_cacher\", None) is not None\n-\n- def _get_cacher(self):\n- \"\"\"return my cacher or None\"\"\"\n- cacher = getattr(self, \"_cacher\", None)\n- if cacher is not None:\n- cacher = cacher[1]()\n- return cacher\n-\n- def _reset_cacher(self) -> None:\n- \"\"\"\n- Reset the cacher.\n- \"\"\"\n- if hasattr(self, \"_cacher\"):\n- del self._cacher\n-\n- def _set_as_cached(self, item, cacher) -> None:\n- \"\"\"\n- Set the _cacher attribute on the calling object with a weakref to\n- cacher.\n- \"\"\"\n- self._cacher = (item, weakref.ref(cacher))\n-\n- def _clear_item_cache(self) -> None:\n- # no-op for Series\n- pass\n-\n- def _check_is_chained_assignment_possible(self) -> bool:\n- \"\"\"\n- See NDFrame._check_is_chained_assignment_possible.__doc__\n- \"\"\"\n- if self._is_view and self._is_cached:\n- ref = self._get_cacher()\n- if ref is not None and ref._is_mixed_type:\n- self._check_setitem_copy(t=\"referent\", force=True)\n- return True\n- return super()._check_is_chained_assignment_possible()\n-\n- def _maybe_update_cacher(\n- self, clear: bool = False, verify_is_copy: bool = True, inplace: bool = False\n- ) -> None:\n- \"\"\"\n- See NDFrame._maybe_update_cacher.__doc__\n- \"\"\"\n- cacher = getattr(self, \"_cacher\", None)\n- if cacher is not None:\n- assert self.ndim == 1\n- ref: DataFrame = cacher[1]()\n-\n- # we are trying to reference a dead referent, hence\n- # a copy\n- if ref is None:\n- del self._cacher\n- elif len(self) == len(ref) and self.name in ref.columns:\n- # GH#42530 self.name must be in ref.columns\n- # to ensure column still in dataframe\n- # otherwise, either self or ref has swapped in new arrays\n- ref._maybe_cache_changed(cacher[0], self, inplace=inplace)\n- else:\n- # GH#33675 we have swapped in a new array, so parent\n- # reference to self is now invalid\n- ref._item_cache.pop(cacher[0], None)\n-\n- super()._maybe_update_cacher(\n- clear=clear, verify_is_copy=verify_is_copy, inplace=inplace\n- )\n-\n- # ----------------------------------------------------------------------\n- # Unsorted\n-\n- @property\n- def _is_mixed_type(self):\n- return False\n-\n- def repeat(self, repeats, axis=None) -> Series:\n- \"\"\"\n- Repeat elements of a Series.\n-\n- Returns a new Series where each element of the current Series\n- is repeated consecutively a given number of times.\n-\n- Parameters\n- ----------\n- repeats : int or array of ints\n- The number of repetitions for each element. This should be a\n- non-negative integer. Repeating 0 times will return an empty\n- Series.\n- axis : None\n- Unused. Parameter needed for compatibility with DataFrame.\n-\n- Returns\n- -------\n- Series\n- Newly created Series with repeated elements.\n-\n- See Also\n- --------\n- Index.repeat : Equivalent function for Index.\n- numpy.repeat : Similar method for :class:`numpy.ndarray`.\n-\n- Examples\n- --------\n- >>> s = pd.Series(['a', 'b', 'c'])\n- >>> s\n- 0 a\n- 1 b\n- 2 c\n- dtype: object\n- >>> s.repeat(2)\n- 0 a\n- 0 a\n- 1 b\n- 1 b\n- 2 c\n- 2 c\n- dtype: object\n- >>> s.repeat([1, 2, 3])\n- 0 a\n- 1 b\n- 1 b\n- 2 c\n- 2 c\n- 2 c\n- dtype: object\n- \"\"\"\n- nv.validate_repeat((), {\"axis\": axis})\n- new_index = self.index.repeat(repeats)\n- new_values = self._values.repeat(repeats)\n- return self._constructor(new_values, index=new_index).__finalize__(\n- self, method=\"repeat\"\n- )\n-\n- @deprecate_nonkeyword_arguments(version=None, allowed_args=[\"self\", \"level\"])\n- def reset_index(\n- self,\n- level=None,\n- drop=False,\n- name=lib.no_default,\n- inplace=False,\n- allow_duplicates: bool = False,\n- ):\n- \"\"\"\n- Generate a new DataFrame or Series with the index reset.\n-\n- This is useful when the index needs to be treated as a column, or\n- when the index is meaningless and needs to be reset to the default\n- before another operation.\n-\n- Parameters\n- ----------\n- level : int, str, tuple, or list, default optional\n- For a Series with a MultiIndex, only remove the specified levels\n- from the index. Removes all levels by default.\n- drop : bool, default False\n- Just reset the index, without inserting it as a column in\n- the new DataFrame.\n- name : object, optional\n- The name to use for the column containing the original Series\n- values. Uses ``self.name`` by default. This argument is ignored\n- when `drop` is True.\n- inplace : bool, default False\n- Modify the Series in place (do not create a new object).\n- allow_duplicates : bool, default False\n- Allow duplicate column labels to be created.\n-\n- .. versionadded:: 1.5.0\n-\n- Returns\n- -------\n- Series or DataFrame or None\n- When `drop` is False (the default), a DataFrame is returned.\n- The newly created columns will come first in the DataFrame,\n- followed by the original Series values.\n- When `drop` is True, a `Series` is returned.\n- In either case, if ``inplace=True``, no value is returned.\n-\n- See Also\n- --------\n- DataFrame.reset_index: Analogous function for DataFrame.\n-\n- Examples\n- --------\n- >>> s = pd.Series([1, 2, 3, 4], name='foo',\n- ... index=pd.Index(['a', 'b', 'c', 'd'], name='idx'))\n-\n- Generate a DataFrame with default index.\n-\n- >>> s.reset_index()\n- idx foo\n- 0 a 1\n- 1 b 2\n- 2 c 3\n- 3 d 4\n-\n- To specify the name of the new column use `name`.\n-\n- >>> s.reset_index(name='values')\n- idx values\n- 0 a 1\n- 1 b 2\n- 2 c 3\n- 3 d 4\n-\n- To generate a new Series with the default set `drop` to True.\n-\n- >>> s.reset_index(drop=True)\n- 0 1\n- 1 2\n- 2 3\n- 3 4\n- Name: foo, dtype: int64\n-\n- To update the Series in place, without generating a new one\n- set `inplace` to True. Note that it also requires ``drop=True``.\n-\n- >>> s.reset_index(inplace=True, drop=True)\n- >>> s\n- 0 1\n- 1 2\n- 2 3\n- 3 4\n- Name: foo, dtype: int64\n-\n- The `level` parameter is interesting for Series with a multi-level\n- index.\n-\n- >>> arrays = [np.array(['bar', 'bar', 'baz', 'baz']),\n- ... np.array(['one', 'two', 'one', 'two'])]\n- >>> s2 = pd.Series(\n- ... range(4), name='foo',\n- ... index=pd.MultiIndex.from_arrays(arrays,\n- ... names=['a', 'b']))\n-\n- To remove a specific level from the Index, use `level`.\n-\n- >>> s2.reset_index(level='a')\n- a foo\n- b\n- one bar 0\n- two bar 1\n- one baz 2\n- two baz 3\n-\n- If `level` is not set, all levels are removed from the Index.\n-\n- >>> s2.reset_index()\n- a b foo\n- 0 bar one 0\n- 1 bar two 1\n- 2 baz one 2\n- 3 baz two 3\n- \"\"\"\n- inplace = validate_bool_kwarg(inplace, \"inplace\")\n- if drop:\n- new_index = default_index(len(self))\n- if level is not None:\n- if not isinstance(level, (tuple, list)):\n- level = [level]\n- level = [self.index._get_level_number(lev) for lev in level]\n- if len(level) < self.index.nlevels:\n- new_index = self.index.droplevel(level)\n-\n- if inplace:\n- self.index = new_index\n- else:\n- return self._constructor(\n- self._values.copy(), index=new_index\n- ).__finalize__(self, method=\"reset_index\")\n- elif inplace:\n- raise TypeError(\n- \"Cannot reset_index inplace on a Series to create a DataFrame\"\n- )\n- else:\n- if name is lib.no_default:\n- # For backwards compatibility, keep columns as [0] instead of\n- # [None] when self.name is None\n- if self.name is None:\n- name = 0\n- else:\n- name = self.name\n-\n- df = self.to_frame(name)\n- return df.reset_index(\n- level=level, drop=drop, allow_duplicates=allow_duplicates\n- )\n-\n- # ----------------------------------------------------------------------\n- # Rendering Methods\n-\n- def __repr__(self) -> str:\n- \"\"\"\n- Return a string representation for a particular Series.\n- \"\"\"\n- repr_params = fmt.get_series_repr_params()\n- return self.to_string(**repr_params)\n-\n- def to_string(\n- self,\n- buf=None,\n- na_rep=\"NaN\",\n- float_format=None,\n- header=True,\n- index=True,\n- length=False,\n- dtype=False,\n- name=False,\n- max_rows=None,\n- min_rows=None,\n- ):\n- \"\"\"\n- Render a string representation of the Series.\n-\n- Parameters\n- ----------\n- buf : StringIO-like, optional\n- Buffer to write to.\n- na_rep : str, optional\n- String representation of NaN to use, default 'NaN'.\n- float_format : one-parameter function, optional\n- Formatter function to apply to columns' elements if they are\n- floats, default None.\n- header : bool, default True\n- Add the Series header (index name).\n- index : bool, optional\n- Add index (row) labels, default True.\n- length : bool, default False\n- Add the Series length.\n- dtype : bool, default False\n- Add the Series dtype.\n- name : bool, default False\n- Add the Series name if not None.\n- max_rows : int, optional\n- Maximum number of rows to show before truncating. If None, show\n- all.\n- min_rows : int, optional\n- The number of rows to display in a truncated repr (when number\n- of rows is above `max_rows`).\n-\n- Returns\n- -------\n- str or None\n- String representation of Series if ``buf=None``, otherwise None.\n- \"\"\"\n- formatter = fmt.SeriesFormatter(\n- self,\n- name=name,\n- length=length,\n- header=header,\n- index=index,\n- dtype=dtype,\n- na_rep=na_rep,\n- float_format=float_format,\n- min_rows=min_rows,\n- max_rows=max_rows,\n- )\n- result = formatter.to_string()\n-\n- # catch contract violations\n- if not isinstance(result, str):\n- raise AssertionError(\n- \"result must be of type str, type \"\n- f\"of result is {repr(type(result).__name__)}\"\n- )\n-\n- if buf is None:\n- return result\n- else:\n- try:\n- buf.write(result)\n- except AttributeError:\n- with open(buf, \"w\") as f:\n- f.write(result)\n-\n- @doc(\n- klass=_shared_doc_kwargs[\"klass\"],\n- storage_options=_shared_docs[\"storage_options\"],\n- examples=dedent(\n- \"\"\"Examples\n- --------\n- >>> s = pd.Series([\"elk\", \"pig\", \"dog\", \"quetzal\"], name=\"animal\")\n- >>> print(s.to_markdown())\n- | | animal |\n- |---:|:---------|\n- | 0 | elk |\n- | 1 | pig |\n- | 2 | dog |\n- | 3 | quetzal |\n-\n- Output markdown with a tabulate option.\n-\n- >>> print(s.to_markdown(tablefmt=\"grid\"))\n- +----+----------+\n- | | animal |\n- +====+==========+\n- | 0 | elk |\n- +----+----------+\n- | 1 | pig |\n- +----+----------+\n- | 2 | dog |\n- +----+----------+\n- | 3 | quetzal |\n- +----+----------+\"\"\"\n- ),\n- )\n- def to_markdown(\n- self,\n- buf: IO[str] | None = None,\n- mode: str = \"wt\",\n- index: bool = True,\n- storage_options: StorageOptions = None,\n- **kwargs,\n- ) -> str | None:\n- \"\"\"\n- Print {klass} in Markdown-friendly format.\n-\n- .. versionadded:: 1.0.0\n-\n- Parameters\n- ----------\n- buf : str, Path or StringIO-like, optional, default None\n- Buffer to write to. If None, the output is returned as a string.\n- mode : str, optional\n- Mode in which file is opened, \"wt\" by default.\n- index : bool, optional, default True\n- Add index (row) labels.\n-\n- .. versionadded:: 1.1.0\n- {storage_options}\n-\n- .. versionadded:: 1.2.0\n-\n- **kwargs\n- These parameters will be passed to `tabulate \\\n- <https://pypi.org/project/tabulate>`_.\n-\n- Returns\n- -------\n- str\n- {klass} in Markdown-friendly format.\n-\n- Notes\n- -----\n- Requires the `tabulate <https://pypi.org/project/tabulate>`_ package.\n-\n- {examples}\n- \"\"\"\n- return self.to_frame().to_markdown(\n- buf, mode, index, storage_options=storage_options, **kwargs\n- )\n-\n- # ----------------------------------------------------------------------\n-\n- def items(self) -> Iterable[tuple[Hashable, Any]]:\n- \"\"\"\n- Lazily iterate over (index, value) tuples.\n-\n- This method returns an iterable tuple (index, value). This is\n- convenient if you want to create a lazy iterator.\n-\n- Returns\n- -------\n- iterable\n- Iterable of tuples containing the (index, value) pairs from a\n- Series.\n-\n- See Also\n- --------\n- DataFrame.items : Iterate over (column name, Series) pairs.\n- DataFrame.iterrows : Iterate over DataFrame rows as (index, Series) pairs.\n-\n- Examples\n- --------\n- >>> s = pd.Series(['A', 'B', 'C'])\n- >>> for index, value in s.items():\n- ... print(f\"Index : {index}, Value : {value}\")\n- Index : 0, Value : A\n- Index : 1, Value : B\n- Index : 2, Value : C\n- \"\"\"\n- return zip(iter(self.index), iter(self))\n-\n- @Appender(items.__doc__)\n- def iteritems(self) -> Iterable[tuple[Hashable, Any]]:\n- warnings.warn(\n- \"iteritems is deprecated and will be removed in a future version. \"\n- \"Use .items instead.\",\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n- return self.items()\n-\n- # ----------------------------------------------------------------------\n- # Misc public methods\n-\n- def keys(self) -> Index:\n- \"\"\"\n- Return alias for index.\n-\n- Returns\n- -------\n- Index\n- Index of the Series.\n- \"\"\"\n- return self.index\n-\n- def to_dict(self, into=dict):\n- \"\"\"\n- Convert Series to {label -> value} dict or dict-like object.\n-\n- Parameters\n- ----------\n- into : class, default dict\n- The collections.abc.Mapping subclass to use as the return\n- object. Can be the actual class or an empty\n- instance of the mapping type you want. If you want a\n- collections.defaultdict, you must pass it initialized.\n-\n- Returns\n- -------\n- collections.abc.Mapping\n- Key-value representation of Series.\n-\n- Examples\n- --------\n- >>> s = pd.Series([1, 2, 3, 4])\n- >>> s.to_dict()\n- {0: 1, 1: 2, 2: 3, 3: 4}\n- >>> from collections import OrderedDict, defaultdict\n- >>> s.to_dict(OrderedDict)\n- OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])\n- >>> dd = defaultdict(list)\n- >>> s.to_dict(dd)\n- defaultdict(<class 'list'>, {0: 1, 1: 2, 2: 3, 3: 4})\n- \"\"\"\n- # GH16122\n- into_c = com.standardize_mapping(into)\n- return into_c((k, maybe_box_native(v)) for k, v in self.items())\n-\n- def to_frame(self, name: Hashable = lib.no_default) -> DataFrame:\n- \"\"\"\n- Convert Series to DataFrame.\n-\n- Parameters\n- ----------\n- name : object, optional\n- The passed name should substitute for the series name (if it has\n- one).\n-\n- Returns\n- -------\n- DataFrame\n- DataFrame representation of Series.\n-\n- Examples\n- --------\n- >>> s = pd.Series([\"a\", \"b\", \"c\"],\n- ... name=\"vals\")\n- >>> s.to_frame()\n- vals\n- 0 a\n- 1 b\n- 2 c\n- \"\"\"\n- if name is None:\n- warnings.warn(\n- \"Explicitly passing `name=None` currently preserves the Series' name \"\n- \"or uses a default name of 0. This behaviour is deprecated, and in \"\n- \"the future `None` will be used as the name of the resulting \"\n- \"DataFrame column.\",\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n- name = lib.no_default\n-\n- columns: Index\n- if name is lib.no_default:\n- name = self.name\n- if name is None:\n- # default to [0], same as we would get with DataFrame(self)\n- columns = default_index(1)\n- else:\n- columns = Index([name])\n- else:\n- columns = Index([name])\n-\n- mgr = self._mgr.to_2d_mgr(columns)\n- df = self._constructor_expanddim(mgr)\n- return df.__finalize__(self, method=\"to_frame\")\n-\n- def _set_name(self, name, inplace=False) -> Series:\n- \"\"\"\n- Set the Series name.\n-\n- Parameters\n- ----------\n- name : str\n- inplace : bool\n- Whether to modify `self` directly or return a copy.\n- \"\"\"\n- inplace = validate_bool_kwarg(inplace, \"inplace\")\n- ser = self if inplace else self.copy()\n- ser.name = name\n- return ser\n-\n- @Appender(\n- \"\"\"\n-Examples\n---------\n->>> ser = pd.Series([390., 350., 30., 20.],\n-... index=['Falcon', 'Falcon', 'Parrot', 'Parrot'], name=\"Max Speed\")\n->>> ser\n-Falcon 390.0\n-Falcon 350.0\n-Parrot 30.0\n-Parrot 20.0\n-Name: Max Speed, dtype: float64\n->>> ser.groupby([\"a\", \"b\", \"a\", \"b\"]).mean()\n-a 210.0\n-b 185.0\n-Name: Max Speed, dtype: float64\n->>> ser.groupby(level=0).mean()\n-Falcon 370.0\n-Parrot 25.0\n-Name: Max Speed, dtype: float64\n->>> ser.groupby(ser > 100).mean()\n-Max Speed\n-False 25.0\n-True 370.0\n-Name: Max Speed, dtype: float64\n-\n-**Grouping by Indexes**\n-\n-We can groupby different levels of a hierarchical index\n-using the `level` parameter:\n-\n->>> arrays = [['Falcon', 'Falcon', 'Parrot', 'Parrot'],\n-... ['Captive', 'Wild', 'Captive', 'Wild']]\n->>> index = pd.MultiIndex.from_arrays(arrays, names=('Animal', 'Type'))\n->>> ser = pd.Series([390., 350., 30., 20.], index=index, name=\"Max Speed\")\n->>> ser\n-Animal Type\n-Falcon Captive 390.0\n- Wild 350.0\n-Parrot Captive 30.0\n- Wild 20.0\n-Name: Max Speed, dtype: float64\n->>> ser.groupby(level=0).mean()\n-Animal\n-Falcon 370.0\n-Parrot 25.0\n-Name: Max Speed, dtype: float64\n->>> ser.groupby(level=\"Type\").mean()\n-Type\n-Captive 210.0\n-Wild 185.0\n-Name: Max Speed, dtype: float64\n-\n-We can also choose to include `NA` in group keys or not by defining\n-`dropna` parameter, the default setting is `True`.\n-\n->>> ser = pd.Series([1, 2, 3, 3], index=[\"a\", 'a', 'b', np.nan])\n->>> ser.groupby(level=0).sum()\n-a 3\n-b 3\n-dtype: int64\n-\n->>> ser.groupby(level=0, dropna=False).sum()\n-a 3\n-b 3\n-NaN 3\n-dtype: int64\n-\n->>> arrays = ['Falcon', 'Falcon', 'Parrot', 'Parrot']\n->>> ser = pd.Series([390., 350., 30., 20.], index=arrays, name=\"Max Speed\")\n->>> ser.groupby([\"a\", \"b\", \"a\", np.nan]).mean()\n-a 210.0\n-b 350.0\n-Name: Max Speed, dtype: float64\n-\n->>> ser.groupby([\"a\", \"b\", \"a\", np.nan], dropna=False).mean()\n-a 210.0\n-b 350.0\n-NaN 20.0\n-Name: Max Speed, dtype: float64\n-\"\"\"\n- )\n- @Appender(_shared_docs[\"groupby\"] % _shared_doc_kwargs)\n- def groupby(\n- self,\n- by=None,\n- axis=0,\n- level=None,\n- as_index: bool = True,\n- sort: bool = True,\n- group_keys: bool | lib.NoDefault = no_default,\n- squeeze: bool | lib.NoDefault = no_default,\n- observed: bool = False,\n- dropna: bool = True,\n- ) -> SeriesGroupBy:\n- from pandas.core.groupby.generic import SeriesGroupBy\n-\n- if squeeze is not no_default:\n- warnings.warn(\n- (\n- \"The `squeeze` parameter is deprecated and \"\n- \"will be removed in a future version.\"\n- ),\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n- else:\n- squeeze = False\n-\n- if level is None and by is None:\n- raise TypeError(\"You have to supply one of 'by' and 'level'\")\n- axis = self._get_axis_number(axis)\n-\n- return SeriesGroupBy(\n- obj=self,\n- keys=by,\n- axis=axis,\n- level=level,\n- as_index=as_index,\n- sort=sort,\n- group_keys=group_keys,\n- squeeze=squeeze,\n- observed=observed,\n- dropna=dropna,\n- )\n-\n- # ----------------------------------------------------------------------\n- # Statistics, overridden ndarray methods\n-\n- # TODO: integrate bottleneck\n-\n- def count(self, level=None):\n- \"\"\"\n- Return number of non-NA/null observations in the Series.\n-\n- Parameters\n- ----------\n- level : int or level name, default None\n- If the axis is a MultiIndex (hierarchical), count along a\n- particular level, collapsing into a smaller Series.\n-\n- Returns\n- -------\n- int or Series (if level specified)\n- Number of non-null values in the Series.\n-\n- See Also\n- --------\n- DataFrame.count : Count non-NA cells for each column or row.\n-\n- Examples\n- --------\n- >>> s = pd.Series([0.0, 1.0, np.nan])\n- >>> s.count()\n- 2\n- \"\"\"\n- if level is None:\n- return notna(self._values).sum().astype(\"int64\")\n- else:\n- warnings.warn(\n- \"Using the level keyword in DataFrame and Series aggregations is \"\n- \"deprecated and will be removed in a future version. Use groupby \"\n- \"instead. ser.count(level=1) should use ser.groupby(level=1).count().\",\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n- if not isinstance(self.index, MultiIndex):\n- raise ValueError(\"Series.count level is only valid with a MultiIndex\")\n-\n- index = self.index\n- assert isinstance(index, MultiIndex) # for mypy\n-\n- if isinstance(level, str):\n- level = index._get_level_number(level)\n-\n- lev = index.levels[level]\n- level_codes = np.array(index.codes[level], subok=False, copy=True)\n-\n- mask = level_codes == -1\n- if mask.any():\n- level_codes[mask] = cnt = len(lev)\n- lev = lev.insert(cnt, lev._na_value)\n-\n- obs = level_codes[notna(self._values)]\n- # error: Argument \"minlength\" to \"bincount\" has incompatible type\n- # \"Optional[int]\"; expected \"SupportsIndex\"\n- out = np.bincount(obs, minlength=len(lev) or None) # type: ignore[arg-type]\n- return self._constructor(out, index=lev, dtype=\"int64\").__finalize__(\n- self, method=\"count\"\n- )\n-\n- def mode(self, dropna: bool = True) -> Series:\n- \"\"\"\n- Return the mode(s) of the Series.\n-\n- The mode is the value that appears most often. There can be multiple modes.\n-\n- Always returns Series even if only one value is returned.\n-\n- Parameters\n- ----------\n- dropna : bool, default True\n- Don't consider counts of NaN/NaT.\n-\n- Returns\n- -------\n- Series\n- Modes of the Series in sorted order.\n- \"\"\"\n- # TODO: Add option for bins like value_counts()\n- values = self._values\n- if isinstance(values, np.ndarray):\n- res_values = algorithms.mode(values, dropna=dropna)\n- else:\n- res_values = values._mode(dropna=dropna)\n-\n- # Ensure index is type stable (should always use int index)\n- return self._constructor(\n- res_values, index=range(len(res_values)), name=self.name\n- )\n-\n- def unique(self) -> ArrayLike:\n- \"\"\"\n- Return unique values of Series object.\n-\n- Uniques are returned in order of appearance. Hash table-based unique,\n- therefore does NOT sort.\n-\n- Returns\n- -------\n- ndarray or ExtensionArray\n- The unique values returned as a NumPy array. See Notes.\n-\n- See Also\n- --------\n- Series.drop_duplicates : Return Series with duplicate values removed.\n- unique : Top-level unique method for any 1-d array-like object.\n- Index.unique : Return Index with unique values from an Index object.\n-\n- Notes\n- -----\n- Returns the unique values as a NumPy array. In case of an\n- extension-array backed Series, a new\n- :class:`~api.extensions.ExtensionArray` of that type with just\n- the unique values is returned. This includes\n-\n- * Categorical\n- * Period\n- * Datetime with Timezone\n- * Interval\n- * Sparse\n- * IntegerNA\n-\n- See Examples section.\n-\n- Examples\n- --------\n- >>> pd.Series([2, 1, 3, 3], name='A').unique()\n- array([2, 1, 3])\n-\n- >>> pd.Series([pd.Timestamp('2016-01-01') for _ in range(3)]).unique()\n- array(['2016-01-01T00:00:00.000000000'], dtype='datetime64[ns]')\n-\n- >>> pd.Series([pd.Timestamp('2016-01-01', tz='US/Eastern')\n- ... for _ in range(3)]).unique()\n- <DatetimeArray>\n- ['2016-01-01 00:00:00-05:00']\n- Length: 1, dtype: datetime64[ns, US/Eastern]\n-\n- An Categorical will return categories in the order of\n- appearance and with the same dtype.\n-\n- >>> pd.Series(pd.Categorical(list('baabc'))).unique()\n- ['b', 'a', 'c']\n- Categories (3, object): ['a', 'b', 'c']\n- >>> pd.Series(pd.Categorical(list('baabc'), categories=list('abc'),\n- ... ordered=True)).unique()\n- ['b', 'a', 'c']\n- Categories (3, object): ['a' < 'b' < 'c']\n- \"\"\"\n- return super().unique()\n-\n- @overload\n- def drop_duplicates(self, keep=..., inplace: Literal[False] = ...) -> Series:\n- ...\n-\n- @overload\n- def drop_duplicates(self, keep, inplace: Literal[True]) -> None:\n- ...\n-\n- @overload\n- def drop_duplicates(self, *, inplace: Literal[True]) -> None:\n- ...\n-\n- @overload\n- def drop_duplicates(self, keep=..., inplace: bool = ...) -> Series | None:\n- ...\n-\n- @deprecate_nonkeyword_arguments(version=None, allowed_args=[\"self\"])\n- def drop_duplicates(self, keep=\"first\", inplace=False) -> Series | None:\n- \"\"\"\n- Return Series with duplicate values removed.\n-\n- Parameters\n- ----------\n- keep : {'first', 'last', ``False``}, default 'first'\n- Method to handle dropping duplicates:\n-\n- - 'first' : Drop duplicates except for the first occurrence.\n- - 'last' : Drop duplicates except for the last occurrence.\n- - ``False`` : Drop all duplicates.\n-\n- inplace : bool, default ``False``\n- If ``True``, performs operation inplace and returns None.\n-\n- Returns\n- -------\n- Series or None\n- Series with duplicates dropped or None if ``inplace=True``.\n-\n- See Also\n- --------\n- Index.drop_duplicates : Equivalent method on Index.\n- DataFrame.drop_duplicates : Equivalent method on DataFrame.\n- Series.duplicated : Related method on Series, indicating duplicate\n- Series values.\n- Series.unique : Return unique values as an array.\n-\n- Examples\n- --------\n- Generate a Series with duplicated entries.\n-\n- >>> s = pd.Series(['lama', 'cow', 'lama', 'beetle', 'lama', 'hippo'],\n- ... name='animal')\n- >>> s\n- 0 lama\n- 1 cow\n- 2 lama\n- 3 beetle\n- 4 lama\n- 5 hippo\n- Name: animal, dtype: object\n-\n- With the 'keep' parameter, the selection behaviour of duplicated values\n- can be changed. The value 'first' keeps the first occurrence for each\n- set of duplicated entries. The default value of keep is 'first'.\n-\n- >>> s.drop_duplicates()\n- 0 lama\n- 1 cow\n- 3 beetle\n- 5 hippo\n- Name: animal, dtype: object\n-\n- The value 'last' for parameter 'keep' keeps the last occurrence for\n- each set of duplicated entries.\n-\n- >>> s.drop_duplicates(keep='last')\n- 1 cow\n- 3 beetle\n- 4 lama\n- 5 hippo\n- Name: animal, dtype: object\n-\n- The value ``False`` for parameter 'keep' discards all sets of\n- duplicated entries. Setting the value of 'inplace' to ``True`` performs\n- the operation inplace and returns ``None``.\n-\n- >>> s.drop_duplicates(keep=False, inplace=True)\n- >>> s\n- 1 cow\n- 3 beetle\n- 5 hippo\n- Name: animal, dtype: object\n- \"\"\"\n- inplace = validate_bool_kwarg(inplace, \"inplace\")\n- result = super().drop_duplicates(keep=keep)\n- if inplace:\n- self._update_inplace(result)\n- return None\n- else:\n- return result\n-\n- def duplicated(self, keep=\"first\") -> Series:\n- \"\"\"\n- Indicate duplicate Series values.\n-\n- Duplicated values are indicated as ``True`` values in the resulting\n- Series. Either all duplicates, all except the first or all except the\n- last occurrence of duplicates can be indicated.\n-\n- Parameters\n- ----------\n- keep : {'first', 'last', False}, default 'first'\n- Method to handle dropping duplicates:\n-\n- - 'first' : Mark duplicates as ``True`` except for the first\n- occurrence.\n- - 'last' : Mark duplicates as ``True`` except for the last\n- occurrence.\n- - ``False`` : Mark all duplicates as ``True``.\n-\n- Returns\n- -------\n- Series[bool]\n- Series indicating whether each value has occurred in the\n- preceding values.\n-\n- See Also\n- --------\n- Index.duplicated : Equivalent method on pandas.Index.\n- DataFrame.duplicated : Equivalent method on pandas.DataFrame.\n- Series.drop_duplicates : Remove duplicate values from Series.\n-\n- Examples\n- --------\n- By default, for each set of duplicated values, the first occurrence is\n- set on False and all others on True:\n-\n- >>> animals = pd.Series(['lama', 'cow', 'lama', 'beetle', 'lama'])\n- >>> animals.duplicated()\n- 0 False\n- 1 False\n- 2 True\n- 3 False\n- 4 True\n- dtype: bool\n-\n- which is equivalent to\n-\n- >>> animals.duplicated(keep='first')\n- 0 False\n- 1 False\n- 2 True\n- 3 False\n- 4 True\n- dtype: bool\n-\n- By using 'last', the last occurrence of each set of duplicated values\n- is set on False and all others on True:\n-\n- >>> animals.duplicated(keep='last')\n- 0 True\n- 1 False\n- 2 True\n- 3 False\n- 4 False\n- dtype: bool\n-\n- By setting keep on ``False``, all duplicates are True:\n-\n- >>> animals.duplicated(keep=False)\n- 0 True\n- 1 False\n- 2 True\n- 3 False\n- 4 True\n- dtype: bool\n- \"\"\"\n- res = self._duplicated(keep=keep)\n- result = self._constructor(res, index=self.index)\n- return result.__finalize__(self, method=\"duplicated\")\n-\n- def idxmin(self, axis=0, skipna=True, *args, **kwargs):\n- \"\"\"\n- Return the row label of the minimum value.\n-\n- If multiple values equal the minimum, the first row label with that\n- value is returned.\n-\n- Parameters\n- ----------\n- axis : {0 or 'index'}\n- Unused. Parameter needed for compatibility with DataFrame.\n- skipna : bool, default True\n- Exclude NA/null values. If the entire Series is NA, the result\n- will be NA.\n- *args, **kwargs\n- Additional arguments and keywords have no effect but might be\n- accepted for compatibility with NumPy.\n-\n- Returns\n- -------\n- Index\n- Label of the minimum value.\n-\n- Raises\n- ------\n- ValueError\n- If the Series is empty.\n-\n- See Also\n- --------\n- numpy.argmin : Return indices of the minimum values\n- along the given axis.\n- DataFrame.idxmin : Return index of first occurrence of minimum\n- over requested axis.\n- Series.idxmax : Return index *label* of the first occurrence\n- of maximum of values.\n-\n- Notes\n- -----\n- This method is the Series version of ``ndarray.argmin``. This method\n- returns the label of the minimum, while ``ndarray.argmin`` returns\n- the position. To get the position, use ``series.values.argmin()``.\n-\n- Examples\n- --------\n- >>> s = pd.Series(data=[1, None, 4, 1],\n- ... index=['A', 'B', 'C', 'D'])\n- >>> s\n- A 1.0\n- B NaN\n- C 4.0\n- D 1.0\n- dtype: float64\n-\n- >>> s.idxmin()\n- 'A'\n-\n- If `skipna` is False and there is an NA value in the data,\n- the function returns ``nan``.\n-\n- >>> s.idxmin(skipna=False)\n- nan\n- \"\"\"\n- i = self.argmin(axis, skipna, *args, **kwargs)\n- if i == -1:\n- return np.nan\n- return self.index[i]\n-\n- def idxmax(self, axis=0, skipna=True, *args, **kwargs):\n- \"\"\"\n- Return the row label of the maximum value.\n-\n- If multiple values equal the maximum, the first row label with that\n- value is returned.\n-\n- Parameters\n- ----------\n- axis : {0 or 'index'}\n- Unused. Parameter needed for compatibility with DataFrame.\n- skipna : bool, default True\n- Exclude NA/null values. If the entire Series is NA, the result\n- will be NA.\n- *args, **kwargs\n- Additional arguments and keywords have no effect but might be\n- accepted for compatibility with NumPy.\n-\n- Returns\n- -------\n- Index\n- Label of the maximum value.\n-\n- Raises\n- ------\n- ValueError\n- If the Series is empty.\n-\n- See Also\n- --------\n- numpy.argmax : Return indices of the maximum values\n- along the given axis.\n- DataFrame.idxmax : Return index of first occurrence of maximum\n- over requested axis.\n- Series.idxmin : Return index *label* of the first occurrence\n- of minimum of values.\n-\n- Notes\n- -----\n- This method is the Series version of ``ndarray.argmax``. This method\n- returns the label of the maximum, while ``ndarray.argmax`` returns\n- the position. To get the position, use ``series.values.argmax()``.\n-\n- Examples\n- --------\n- >>> s = pd.Series(data=[1, None, 4, 3, 4],\n- ... index=['A', 'B', 'C', 'D', 'E'])\n- >>> s\n- A 1.0\n- B NaN\n- C 4.0\n- D 3.0\n- E 4.0\n- dtype: float64\n-\n- >>> s.idxmax()\n- 'C'\n-\n- If `skipna` is False and there is an NA value in the data,\n- the function returns ``nan``.\n-\n- >>> s.idxmax(skipna=False)\n- nan\n- \"\"\"\n- i = self.argmax(axis, skipna, *args, **kwargs)\n- if i == -1:\n- return np.nan\n- return self.index[i]\n-\n- def round(self, decimals=0, *args, **kwargs) -> Series:\n- \"\"\"\n- Round each value in a Series to the given number of decimals.\n-\n- Parameters\n- ----------\n- decimals : int, default 0\n- Number of decimal places to round to. If decimals is negative,\n- it specifies the number of positions to the left of the decimal point.\n- *args, **kwargs\n- Additional arguments and keywords have no effect but might be\n- accepted for compatibility with NumPy.\n-\n- Returns\n- -------\n- Series\n- Rounded values of the Series.\n-\n- See Also\n- --------\n- numpy.around : Round values of an np.array.\n- DataFrame.round : Round values of a DataFrame.\n-\n- Examples\n- --------\n- >>> s = pd.Series([0.1, 1.3, 2.7])\n- >>> s.round()\n- 0 0.0\n- 1 1.0\n- 2 3.0\n- dtype: float64\n- \"\"\"\n- nv.validate_round(args, kwargs)\n- result = self._values.round(decimals)\n- result = self._constructor(result, index=self.index).__finalize__(\n- self, method=\"round\"\n- )\n-\n- return result\n-\n- @overload\n- def quantile(\n- self, q: float = ..., interpolation: QuantileInterpolation = ...\n- ) -> float:\n- ...\n-\n- @overload\n- def quantile(\n- self,\n- q: Sequence[float] | AnyArrayLike,\n- interpolation: QuantileInterpolation = ...,\n- ) -> Series:\n- ...\n-\n- @overload\n- def quantile(\n- self,\n- q: float | Sequence[float] | AnyArrayLike = ...,\n- interpolation: QuantileInterpolation = ...,\n- ) -> float | Series:\n- ...\n-\n- def quantile(\n- self,\n- q: float | Sequence[float] | AnyArrayLike = 0.5,\n- interpolation: QuantileInterpolation = \"linear\",\n- ) -> float | Series:\n- \"\"\"\n- Return value at the given quantile.\n-\n- Parameters\n- ----------\n- q : float or array-like, default 0.5 (50% quantile)\n- The quantile(s) to compute, which can lie in range: 0 <= q <= 1.\n- interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}\n- This optional parameter specifies the interpolation method to use,\n- when the desired quantile lies between two data points `i` and `j`:\n-\n- * linear: `i + (j - i) * fraction`, where `fraction` is the\n- fractional part of the index surrounded by `i` and `j`.\n- * lower: `i`.\n- * higher: `j`.\n- * nearest: `i` or `j` whichever is nearest.\n- * midpoint: (`i` + `j`) / 2.\n-\n- Returns\n- -------\n- float or Series\n- If ``q`` is an array, a Series will be returned where the\n- index is ``q`` and the values are the quantiles, otherwise\n- a float will be returned.\n-\n- See Also\n- --------\n- core.window.Rolling.quantile : Calculate the rolling quantile.\n- numpy.percentile : Returns the q-th percentile(s) of the array elements.\n-\n- Examples\n- --------\n- >>> s = pd.Series([1, 2, 3, 4])\n- >>> s.quantile(.5)\n- 2.5\n- >>> s.quantile([.25, .5, .75])\n- 0.25 1.75\n- 0.50 2.50\n- 0.75 3.25\n- dtype: float64\n- \"\"\"\n- validate_percentile(q)\n-\n- # We dispatch to DataFrame so that core.internals only has to worry\n- # about 2D cases.\n- df = self.to_frame()\n-\n- result = df.quantile(q=q, interpolation=interpolation, numeric_only=False)\n- if result.ndim == 2:\n- result = result.iloc[:, 0]\n-\n- if is_list_like(q):\n- result.name = self.name\n- return self._constructor(result, index=Float64Index(q), name=self.name)\n- else:\n- # scalar\n- return result.iloc[0]\n-\n- def corr(self, other, method=\"pearson\", min_periods=None) -> float:\n- \"\"\"\n- Compute correlation with `other` Series, excluding missing values.\n- The two `Series` objects are not required to be the same length and will be\n- aligned internally before the correlation function is applied.\n-\n- Parameters\n- ----------\n- other : Series\n- Series with which to compute the correlation.\n- method : {'pearson', 'kendall', 'spearman'} or callable\n- Method used to compute correlation:\n-\n- - pearson : Standard correlation coefficient\n- - kendall : Kendall Tau correlation coefficient\n- - spearman : Spearman rank correlation\n- - callable: Callable with input two 1d ndarrays and returning a float.\n-\n- .. warning::\n- Note that the returned matrix from corr will have 1 along the\n- diagonals and will be symmetric regardless of the callable's\n- behavior.\n- min_periods : int, optional\n- Minimum number of observations needed to have a valid result.\n-\n- Returns\n- -------\n- float\n- Correlation with other.\n-\n- See Also\n- --------\n- DataFrame.corr : Compute pairwise correlation between columns.\n- DataFrame.corrwith : Compute pairwise correlation with another\n- DataFrame or Series.\n-\n- Notes\n- -----\n- Pearson, Kendall and Spearman correlation are currently computed using pairwise complete observations.\n-\n- * `Pearson correlation coefficient <https://en.wikipedia.org/wiki/Pearson_correlation_coefficient>`_\n- * `Kendall rank correlation coefficient <https://en.wikipedia.org/wiki/Kendall_rank_correlation_coefficient>`_\n- * `Spearman's rank correlation coefficient <https://en.wikipedia.org/wiki/Spearman%27s_rank_correlation_coefficient>`_\n-\n- Examples\n- --------\n- >>> def histogram_intersection(a, b):\n- ... v = np.minimum(a, b).sum().round(decimals=1)\n- ... return v\n- >>> s1 = pd.Series([.2, .0, .6, .2])\n- >>> s2 = pd.Series([.3, .6, .0, .1])\n- >>> s1.corr(s2, method=histogram_intersection)\n- 0.3\n- \"\"\" # noqa:E501\n- this, other = self.align(other, join=\"inner\", copy=False)\n- if len(this) == 0:\n- return np.nan\n-\n- if method in [\"pearson\", \"spearman\", \"kendall\"] or callable(method):\n- return nanops.nancorr(\n- this.values, other.values, method=method, min_periods=min_periods\n- )\n-\n- raise ValueError(\n- \"method must be either 'pearson', \"\n- \"'spearman', 'kendall', or a callable, \"\n- f\"'{method}' was supplied\"\n- )\n-\n- def cov(\n- self,\n- other: Series,\n- min_periods: int | None = None,\n- ddof: int | None = 1,\n- ) -> float:\n- \"\"\"\n- Compute covariance with Series, excluding missing values.\n- The two `Series` objects are not required to be the same length and\n- will be aligned internally before the covariance is calculated.\n-\n- Parameters\n- ----------\n- other : Series\n- Series with which to compute the covariance.\n- min_periods : int, optional\n- Minimum number of observations needed to have a valid result.\n- ddof : int, default 1\n- Delta degrees of freedom. The divisor used in calculations\n- is ``N - ddof``, where ``N`` represents the number of elements.\n-\n- .. versionadded:: 1.1.0\n-\n- Returns\n- -------\n- float\n- Covariance between Series and other normalized by N-1\n- (unbiased estimator).\n-\n- See Also\n- --------\n- DataFrame.cov : Compute pairwise covariance of columns.\n-\n- Examples\n- --------\n- >>> s1 = pd.Series([0.90010907, 0.13484424, 0.62036035])\n- >>> s2 = pd.Series([0.12528585, 0.26962463, 0.51111198])\n- >>> s1.cov(s2)\n- -0.01685762652715874\n- \"\"\"\n- this, other = self.align(other, join=\"inner\", copy=False)\n- if len(this) == 0:\n- return np.nan\n- return nanops.nancov(\n- this.values, other.values, min_periods=min_periods, ddof=ddof\n- )\n-\n- @doc(\n- klass=\"Series\",\n- extra_params=\"\",\n- other_klass=\"DataFrame\",\n- examples=dedent(\n- \"\"\"\n- Difference with previous row\n-\n- >>> s = pd.Series([1, 1, 2, 3, 5, 8])\n- >>> s.diff()\n- 0 NaN\n- 1 0.0\n- 2 1.0\n- 3 1.0\n- 4 2.0\n- 5 3.0\n- dtype: float64\n-\n- Difference with 3rd previous row\n-\n- >>> s.diff(periods=3)\n- 0 NaN\n- 1 NaN\n- 2 NaN\n- 3 2.0\n- 4 4.0\n- 5 6.0\n- dtype: float64\n-\n- Difference with following row\n-\n- >>> s.diff(periods=-1)\n- 0 0.0\n- 1 -1.0\n- 2 -1.0\n- 3 -2.0\n- 4 -3.0\n- 5 NaN\n- dtype: float64\n-\n- Overflow in input dtype\n-\n- >>> s = pd.Series([1, 0], dtype=np.uint8)\n- >>> s.diff()\n- 0 NaN\n- 1 255.0\n- dtype: float64\"\"\"\n- ),\n- )\n- def diff(self, periods: int = 1) -> Series:\n- \"\"\"\n- First discrete difference of element.\n-\n- Calculates the difference of a {klass} element compared with another\n- element in the {klass} (default is element in previous row).\n-\n- Parameters\n- ----------\n- periods : int, default 1\n- Periods to shift for calculating difference, accepts negative\n- values.\n- {extra_params}\n- Returns\n- -------\n- {klass}\n- First differences of the Series.\n-\n- See Also\n- --------\n- {klass}.pct_change: Percent change over given number of periods.\n- {klass}.shift: Shift index by desired number of periods with an\n- optional time freq.\n- {other_klass}.diff: First discrete difference of object.\n-\n- Notes\n- -----\n- For boolean dtypes, this uses :meth:`operator.xor` rather than\n- :meth:`operator.sub`.\n- The result is calculated according to current dtype in {klass},\n- however dtype of the result is always float64.\n-\n- Examples\n- --------\n- {examples}\n- \"\"\"\n- result = algorithms.diff(self._values, periods)\n- return self._constructor(result, index=self.index).__finalize__(\n- self, method=\"diff\"\n- )\n-\n- def autocorr(self, lag=1) -> float:\n- \"\"\"\n- Compute the lag-N autocorrelation.\n-\n- This method computes the Pearson correlation between\n- the Series and its shifted self.\n-\n- Parameters\n- ----------\n- lag : int, default 1\n- Number of lags to apply before performing autocorrelation.\n-\n- Returns\n- -------\n- float\n- The Pearson correlation between self and self.shift(lag).\n-\n- See Also\n- --------\n- Series.corr : Compute the correlation between two Series.\n- Series.shift : Shift index by desired number of periods.\n- DataFrame.corr : Compute pairwise correlation of columns.\n- DataFrame.corrwith : Compute pairwise correlation between rows or\n- columns of two DataFrame objects.\n-\n- Notes\n- -----\n- If the Pearson correlation is not well defined return 'NaN'.\n-\n- Examples\n- --------\n- >>> s = pd.Series([0.25, 0.5, 0.2, -0.05])\n- >>> s.autocorr() # doctest: +ELLIPSIS\n- 0.10355...\n- >>> s.autocorr(lag=2) # doctest: +ELLIPSIS\n- -0.99999...\n-\n- If the Pearson correlation is not well defined, then 'NaN' is returned.\n-\n- >>> s = pd.Series([1, 0, 0, 0])\n- >>> s.autocorr()\n- nan\n- \"\"\"\n- return self.corr(self.shift(lag))\n-\n- def dot(self, other):\n- \"\"\"\n- Compute the dot product between the Series and the columns of other.\n-\n- This method computes the dot product between the Series and another\n- one, or the Series and each columns of a DataFrame, or the Series and\n- each columns of an array.\n-\n- It can also be called using `self @ other` in Python >= 3.5.\n-\n- Parameters\n- ----------\n- other : Series, DataFrame or array-like\n- The other object to compute the dot product with its columns.\n-\n- Returns\n- -------\n- scalar, Series or numpy.ndarray\n- Return the dot product of the Series and other if other is a\n- Series, the Series of the dot product of Series and each rows of\n- other if other is a DataFrame or a numpy.ndarray between the Series\n- and each columns of the numpy array.\n-\n- See Also\n- --------\n- DataFrame.dot: Compute the matrix product with the DataFrame.\n- Series.mul: Multiplication of series and other, element-wise.\n-\n- Notes\n- -----\n- The Series and other has to share the same index if other is a Series\n- or a DataFrame.\n-\n- Examples\n- --------\n- >>> s = pd.Series([0, 1, 2, 3])\n- >>> other = pd.Series([-1, 2, -3, 4])\n- >>> s.dot(other)\n- 8\n- >>> s @ other\n- 8\n- >>> df = pd.DataFrame([[0, 1], [-2, 3], [4, -5], [6, 7]])\n- >>> s.dot(df)\n- 0 24\n- 1 14\n- dtype: int64\n- >>> arr = np.array([[0, 1], [-2, 3], [4, -5], [6, 7]])\n- >>> s.dot(arr)\n- array([24, 14])\n- \"\"\"\n- if isinstance(other, (Series, ABCDataFrame)):\n- common = self.index.union(other.index)\n- if len(common) > len(self.index) or len(common) > len(other.index):\n- raise ValueError(\"matrices are not aligned\")\n-\n- left = self.reindex(index=common, copy=False)\n- right = other.reindex(index=common, copy=False)\n- lvals = left.values\n- rvals = right.values\n- else:\n- lvals = self.values\n- rvals = np.asarray(other)\n- if lvals.shape[0] != rvals.shape[0]:\n- raise Exception(\n- f\"Dot product shape mismatch, {lvals.shape} vs {rvals.shape}\"\n- )\n-\n- if isinstance(other, ABCDataFrame):\n- return self._constructor(\n- np.dot(lvals, rvals), index=other.columns\n- ).__finalize__(self, method=\"dot\")\n- elif isinstance(other, Series):\n- return np.dot(lvals, rvals)\n- elif isinstance(rvals, np.ndarray):\n- return np.dot(lvals, rvals)\n- else: # pragma: no cover\n- raise TypeError(f\"unsupported type: {type(other)}\")\n-\n- def __matmul__(self, other):\n- \"\"\"\n- Matrix multiplication using binary `@` operator in Python>=3.5.\n- \"\"\"\n- return self.dot(other)\n-\n- def __rmatmul__(self, other):\n- \"\"\"\n- Matrix multiplication using binary `@` operator in Python>=3.5.\n- \"\"\"\n- return self.dot(np.transpose(other))\n-\n- @doc(base.IndexOpsMixin.searchsorted, klass=\"Series\")\n- # Signature of \"searchsorted\" incompatible with supertype \"IndexOpsMixin\"\n- def searchsorted( # type: ignore[override]\n- self,\n- value: NumpyValueArrayLike | ExtensionArray,\n- side: Literal[\"left\", \"right\"] = \"left\",\n- sorter: NumpySorter = None,\n- ) -> npt.NDArray[np.intp] | np.intp:\n- return base.IndexOpsMixin.searchsorted(self, value, side=side, sorter=sorter)\n-\n- # -------------------------------------------------------------------\n- # Combination\n-\n- def append(\n- self, to_append, ignore_index: bool = False, verify_integrity: bool = False\n- ):\n- \"\"\"\n- Concatenate two or more Series.\n-\n- .. deprecated:: 1.4.0\n- Use :func:`concat` instead. For further details see\n- :ref:`whatsnew_140.deprecations.frame_series_append`\n-\n- Parameters\n- ----------\n- to_append : Series or list/tuple of Series\n- Series to append with self.\n- ignore_index : bool, default False\n- If True, the resulting axis will be labeled 0, 1, …, n - 1.\n- verify_integrity : bool, default False\n- If True, raise Exception on creating index with duplicates.\n-\n- Returns\n- -------\n- Series\n- Concatenated Series.\n-\n- See Also\n- --------\n- concat : General function to concatenate DataFrame or Series objects.\n-\n- Notes\n- -----\n- Iteratively appending to a Series can be more computationally intensive\n- than a single concatenate. A better solution is to append values to a\n- list and then concatenate the list with the original Series all at\n- once.\n-\n- Examples\n- --------\n- >>> s1 = pd.Series([1, 2, 3])\n- >>> s2 = pd.Series([4, 5, 6])\n- >>> s3 = pd.Series([4, 5, 6], index=[3, 4, 5])\n- >>> s1.append(s2)\n- 0 1\n- 1 2\n- 2 3\n- 0 4\n- 1 5\n- 2 6\n- dtype: int64\n-\n- >>> s1.append(s3)\n- 0 1\n- 1 2\n- 2 3\n- 3 4\n- 4 5\n- 5 6\n- dtype: int64\n-\n- With `ignore_index` set to True:\n-\n- >>> s1.append(s2, ignore_index=True)\n- 0 1\n- 1 2\n- 2 3\n- 3 4\n- 4 5\n- 5 6\n- dtype: int64\n-\n- With `verify_integrity` set to True:\n-\n- >>> s1.append(s2, verify_integrity=True)\n- Traceback (most recent call last):\n- ...\n- ValueError: Indexes have overlapping values: [0, 1, 2]\n- \"\"\"\n- warnings.warn(\n- \"The series.append method is deprecated \"\n- \"and will be removed from pandas in a future version. \"\n- \"Use pandas.concat instead.\",\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n-\n- return self._append(to_append, ignore_index, verify_integrity)\n-\n- def _append(\n- self, to_append, ignore_index: bool = False, verify_integrity: bool = False\n- ):\n- from pandas.core.reshape.concat import concat\n-\n- if isinstance(to_append, (list, tuple)):\n- to_concat = [self]\n- to_concat.extend(to_append)\n- else:\n- to_concat = [self, to_append]\n- if any(isinstance(x, (ABCDataFrame,)) for x in to_concat[1:]):\n- msg = \"to_append should be a Series or list/tuple of Series, got DataFrame\"\n- raise TypeError(msg)\n- return concat(\n- to_concat, ignore_index=ignore_index, verify_integrity=verify_integrity\n- )\n-\n- def _binop(self, other: Series, func, level=None, fill_value=None):\n- \"\"\"\n- Perform generic binary operation with optional fill value.\n-\n- Parameters\n- ----------\n- other : Series\n- func : binary operator\n- fill_value : float or object\n- Value to substitute for NA/null values. If both Series are NA in a\n- location, the result will be NA regardless of the passed fill value.\n- level : int or level name, default None\n- Broadcast across a level, matching Index values on the\n- passed MultiIndex level.\n-\n- Returns\n- -------\n- Series\n- \"\"\"\n- if not isinstance(other, Series):\n- raise AssertionError(\"Other operand must be Series\")\n-\n- this = self\n-\n- if not self.index.equals(other.index):\n- this, other = self.align(other, level=level, join=\"outer\", copy=False)\n-\n- this_vals, other_vals = ops.fill_binop(this._values, other._values, fill_value)\n-\n- with np.errstate(all=\"ignore\"):\n- result = func(this_vals, other_vals)\n-\n- name = ops.get_op_result_name(self, other)\n- return this._construct_result(result, name)\n-\n- def _construct_result(\n- self, result: ArrayLike | tuple[ArrayLike, ArrayLike], name: Hashable\n- ) -> Series | tuple[Series, Series]:\n- \"\"\"\n- Construct an appropriately-labelled Series from the result of an op.\n-\n- Parameters\n- ----------\n- result : ndarray or ExtensionArray\n- name : Label\n-\n- Returns\n- -------\n- Series\n- In the case of __divmod__ or __rdivmod__, a 2-tuple of Series.\n- \"\"\"\n- if isinstance(result, tuple):\n- # produced by divmod or rdivmod\n-\n- res1 = self._construct_result(result[0], name=name)\n- res2 = self._construct_result(result[1], name=name)\n-\n- # GH#33427 assertions to keep mypy happy\n- assert isinstance(res1, Series)\n- assert isinstance(res2, Series)\n- return (res1, res2)\n-\n- # We do not pass dtype to ensure that the Series constructor\n- # does inference in the case where `result` has object-dtype.\n- out = self._constructor(result, index=self.index)\n- out = out.__finalize__(self)\n-\n- # Set the result's name after __finalize__ is called because __finalize__\n- # would set it back to self.name\n- out.name = name\n- return out\n-\n- @doc(\n- _shared_docs[\"compare\"],\n- \"\"\"\n-Returns\n--------\n-Series or DataFrame\n- If axis is 0 or 'index' the result will be a Series.\n- The resulting index will be a MultiIndex with 'self' and 'other'\n- stacked alternately at the inner level.\n-\n- If axis is 1 or 'columns' the result will be a DataFrame.\n- It will have two columns namely 'self' and 'other'.\n-\n-See Also\n---------\n-DataFrame.compare : Compare with another DataFrame and show differences.\n-\n-Notes\n------\n-Matching NaNs will not appear as a difference.\n-\n-Examples\n---------\n->>> s1 = pd.Series([\"a\", \"b\", \"c\", \"d\", \"e\"])\n->>> s2 = pd.Series([\"a\", \"a\", \"c\", \"b\", \"e\"])\n-\n-Align the differences on columns\n-\n->>> s1.compare(s2)\n- self other\n-1 b a\n-3 d b\n-\n-Stack the differences on indices\n-\n->>> s1.compare(s2, align_axis=0)\n-1 self b\n- other a\n-3 self d\n- other b\n-dtype: object\n-\n-Keep all original rows\n-\n->>> s1.compare(s2, keep_shape=True)\n- self other\n-0 NaN NaN\n-1 b a\n-2 NaN NaN\n-3 d b\n-4 NaN NaN\n-\n-Keep all original rows and also all original values\n-\n->>> s1.compare(s2, keep_shape=True, keep_equal=True)\n- self other\n-0 a a\n-1 b a\n-2 c c\n-3 d b\n-4 e e\n-\"\"\",\n- klass=_shared_doc_kwargs[\"klass\"],\n- )\n- def compare(\n- self,\n- other: Series,\n- align_axis: Axis = 1,\n- keep_shape: bool = False,\n- keep_equal: bool = False,\n- ) -> DataFrame | Series:\n- return super().compare(\n- other=other,\n- align_axis=align_axis,\n- keep_shape=keep_shape,\n- keep_equal=keep_equal,\n- )\n-\n- def combine(self, other, func, fill_value=None) -> Series:\n- \"\"\"\n- Combine the Series with a Series or scalar according to `func`.\n-\n- Combine the Series and `other` using `func` to perform elementwise\n- selection for combined Series.\n- `fill_value` is assumed when value is missing at some index\n- from one of the two objects being combined.\n-\n- Parameters\n- ----------\n- other : Series or scalar\n- The value(s) to be combined with the `Series`.\n- func : function\n- Function that takes two scalars as inputs and returns an element.\n- fill_value : scalar, optional\n- The value to assume when an index is missing from\n- one Series or the other. The default specifies to use the\n- appropriate NaN value for the underlying dtype of the Series.\n-\n- Returns\n- -------\n- Series\n- The result of combining the Series with the other object.\n-\n- See Also\n- --------\n- Series.combine_first : Combine Series values, choosing the calling\n- Series' values first.\n-\n- Examples\n- --------\n- Consider 2 Datasets ``s1`` and ``s2`` containing\n- highest clocked speeds of different birds.\n-\n- >>> s1 = pd.Series({'falcon': 330.0, 'eagle': 160.0})\n- >>> s1\n- falcon 330.0\n- eagle 160.0\n- dtype: float64\n- >>> s2 = pd.Series({'falcon': 345.0, 'eagle': 200.0, 'duck': 30.0})\n- >>> s2\n- falcon 345.0\n- eagle 200.0\n- duck 30.0\n- dtype: float64\n-\n- Now, to combine the two datasets and view the highest speeds\n- of the birds across the two datasets\n-\n- >>> s1.combine(s2, max)\n- duck NaN\n- eagle 200.0\n- falcon 345.0\n- dtype: float64\n-\n- In the previous example, the resulting value for duck is missing,\n- because the maximum of a NaN and a float is a NaN.\n- So, in the example, we set ``fill_value=0``,\n- so the maximum value returned will be the value from some dataset.\n-\n- >>> s1.combine(s2, max, fill_value=0)\n- duck 30.0\n- eagle 200.0\n- falcon 345.0\n- dtype: float64\n- \"\"\"\n- if fill_value is None:\n- fill_value = na_value_for_dtype(self.dtype, compat=False)\n-\n- if isinstance(other, Series):\n- # If other is a Series, result is based on union of Series,\n- # so do this element by element\n- new_index = self.index.union(other.index)\n- new_name = ops.get_op_result_name(self, other)\n- new_values = np.empty(len(new_index), dtype=object)\n- for i, idx in enumerate(new_index):\n- lv = self.get(idx, fill_value)\n- rv = other.get(idx, fill_value)\n- with np.errstate(all=\"ignore\"):\n- new_values[i] = func(lv, rv)\n- else:\n- # Assume that other is a scalar, so apply the function for\n- # each element in the Series\n- new_index = self.index\n- new_values = np.empty(len(new_index), dtype=object)\n- with np.errstate(all=\"ignore\"):\n- new_values[:] = [func(lv, other) for lv in self._values]\n- new_name = self.name\n-\n- # try_float=False is to match agg_series\n- npvalues = lib.maybe_convert_objects(new_values, try_float=False)\n- res_values = maybe_cast_pointwise_result(npvalues, self.dtype, same_dtype=False)\n- return self._constructor(res_values, index=new_index, name=new_name)\n-\n- def combine_first(self, other) -> Series:\n- \"\"\"\n- Update null elements with value in the same location in 'other'.\n-\n- Combine two Series objects by filling null values in one Series with\n- non-null values from the other Series. Result index will be the union\n- of the two indexes.\n-\n- Parameters\n- ----------\n- other : Series\n- The value(s) to be used for filling null values.\n-\n- Returns\n- -------\n- Series\n- The result of combining the provided Series with the other object.\n-\n- See Also\n- --------\n- Series.combine : Perform element-wise operation on two Series\n- using a given function.\n-\n- Examples\n- --------\n- >>> s1 = pd.Series([1, np.nan])\n- >>> s2 = pd.Series([3, 4, 5])\n- >>> s1.combine_first(s2)\n- 0 1.0\n- 1 4.0\n- 2 5.0\n- dtype: float64\n-\n- Null values still persist if the location of that null value\n- does not exist in `other`\n-\n- >>> s1 = pd.Series({'falcon': np.nan, 'eagle': 160.0})\n- >>> s2 = pd.Series({'eagle': 200.0, 'duck': 30.0})\n- >>> s1.combine_first(s2)\n- duck 30.0\n- eagle 160.0\n- falcon NaN\n- dtype: float64\n- \"\"\"\n- new_index = self.index.union(other.index)\n- this = self.reindex(new_index, copy=False)\n- other = other.reindex(new_index, copy=False)\n- if this.dtype.kind == \"M\" and other.dtype.kind != \"M\":\n- other = to_datetime(other)\n-\n- return this.where(notna(this), other)\n-\n- def update(self, other) -> None:\n- \"\"\"\n- Modify Series in place using values from passed Series.\n-\n- Uses non-NA values from passed Series to make updates. Aligns\n- on index.\n-\n- Parameters\n- ----------\n- other : Series, or object coercible into Series\n-\n- Examples\n- --------\n- >>> s = pd.Series([1, 2, 3])\n- >>> s.update(pd.Series([4, 5, 6]))\n- >>> s\n- 0 4\n- 1 5\n- 2 6\n- dtype: int64\n-\n- >>> s = pd.Series(['a', 'b', 'c'])\n- >>> s.update(pd.Series(['d', 'e'], index=[0, 2]))\n- >>> s\n- 0 d\n- 1 b\n- 2 e\n- dtype: object\n-\n- >>> s = pd.Series([1, 2, 3])\n- >>> s.update(pd.Series([4, 5, 6, 7, 8]))\n- >>> s\n- 0 4\n- 1 5\n- 2 6\n- dtype: int64\n-\n- If ``other`` contains NaNs the corresponding values are not updated\n- in the original Series.\n-\n- >>> s = pd.Series([1, 2, 3])\n- >>> s.update(pd.Series([4, np.nan, 6]))\n- >>> s\n- 0 4\n- 1 2\n- 2 6\n- dtype: int64\n-\n- ``other`` can also be a non-Series object type\n- that is coercible into a Series\n-\n- >>> s = pd.Series([1, 2, 3])\n- >>> s.update([4, np.nan, 6])\n- >>> s\n- 0 4\n- 1 2\n- 2 6\n- dtype: int64\n-\n- >>> s = pd.Series([1, 2, 3])\n- >>> s.update({1: 9})\n- >>> s\n- 0 1\n- 1 9\n- 2 3\n- dtype: int64\n- \"\"\"\n-\n- if not isinstance(other, Series):\n- other = Series(other)\n-\n- other = other.reindex_like(self)\n- mask = notna(other)\n-\n- self._mgr = self._mgr.putmask(mask=mask, new=other)\n- self._maybe_update_cacher()\n-\n- # ----------------------------------------------------------------------\n- # Reindexing, sorting\n-\n- @deprecate_nonkeyword_arguments(version=None, allowed_args=[\"self\"])\n- def sort_values(\n- self,\n- axis=0,\n- ascending: bool | int | Sequence[bool | int] = True,\n- inplace: bool = False,\n- kind: str = \"quicksort\",\n- na_position: str = \"last\",\n- ignore_index: bool = False,\n- key: ValueKeyFunc = None,\n- ):\n- \"\"\"\n- Sort by the values.\n-\n- Sort a Series in ascending or descending order by some\n- criterion.\n-\n- Parameters\n- ----------\n- axis : {0 or 'index'}\n- Unused. Parameter needed for compatibility with DataFrame.\n- ascending : bool or list of bools, default True\n- If True, sort values in ascending order, otherwise descending.\n- inplace : bool, default False\n- If True, perform operation in-place.\n- kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, default 'quicksort'\n- Choice of sorting algorithm. See also :func:`numpy.sort` for more\n- information. 'mergesort' and 'stable' are the only stable algorithms.\n- na_position : {'first' or 'last'}, default 'last'\n- Argument 'first' puts NaNs at the beginning, 'last' puts NaNs at\n- the end.\n- ignore_index : bool, default False\n- If True, the resulting axis will be labeled 0, 1, …, n - 1.\n-\n- .. versionadded:: 1.0.0\n-\n- key : callable, optional\n- If not None, apply the key function to the series values\n- before sorting. This is similar to the `key` argument in the\n- builtin :meth:`sorted` function, with the notable difference that\n- this `key` function should be *vectorized*. It should expect a\n- ``Series`` and return an array-like.\n-\n- .. versionadded:: 1.1.0\n-\n- Returns\n- -------\n- Series or None\n- Series ordered by values or None if ``inplace=True``.\n-\n- See Also\n- --------\n- Series.sort_index : Sort by the Series indices.\n- DataFrame.sort_values : Sort DataFrame by the values along either axis.\n- DataFrame.sort_index : Sort DataFrame by indices.\n-\n- Examples\n- --------\n- >>> s = pd.Series([np.nan, 1, 3, 10, 5])\n- >>> s\n- 0 NaN\n- 1 1.0\n- 2 3.0\n- 3 10.0\n- 4 5.0\n- dtype: float64\n-\n- Sort values ascending order (default behaviour)\n-\n- >>> s.sort_values(ascending=True)\n- 1 1.0\n- 2 3.0\n- 4 5.0\n- 3 10.0\n- 0 NaN\n- dtype: float64\n-\n- Sort values descending order\n-\n- >>> s.sort_values(ascending=False)\n- 3 10.0\n- 4 5.0\n- 2 3.0\n- 1 1.0\n- 0 NaN\n- dtype: float64\n-\n- Sort values inplace\n-\n- >>> s.sort_values(ascending=False, inplace=True)\n- >>> s\n- 3 10.0\n- 4 5.0\n- 2 3.0\n- 1 1.0\n- 0 NaN\n- dtype: float64\n-\n- Sort values putting NAs first\n-\n- >>> s.sort_values(na_position='first')\n- 0 NaN\n- 1 1.0\n- 2 3.0\n- 4 5.0\n- 3 10.0\n- dtype: float64\n-\n- Sort a series of strings\n-\n- >>> s = pd.Series(['z', 'b', 'd', 'a', 'c'])\n- >>> s\n- 0 z\n- 1 b\n- 2 d\n- 3 a\n- 4 c\n- dtype: object\n-\n- >>> s.sort_values()\n- 3 a\n- 1 b\n- 4 c\n- 2 d\n- 0 z\n- dtype: object\n-\n- Sort using a key function. Your `key` function will be\n- given the ``Series`` of values and should return an array-like.\n-\n- >>> s = pd.Series(['a', 'B', 'c', 'D', 'e'])\n- >>> s.sort_values()\n- 1 B\n- 3 D\n- 0 a\n- 2 c\n- 4 e\n- dtype: object\n- >>> s.sort_values(key=lambda x: x.str.lower())\n- 0 a\n- 1 B\n- 2 c\n- 3 D\n- 4 e\n- dtype: object\n-\n- NumPy ufuncs work well here. For example, we can\n- sort by the ``sin`` of the value\n-\n- >>> s = pd.Series([-4, -2, 0, 2, 4])\n- >>> s.sort_values(key=np.sin)\n- 1 -2\n- 4 4\n- 2 0\n- 0 -4\n- 3 2\n- dtype: int64\n-\n- More complicated user-defined functions can be used,\n- as long as they expect a Series and return an array-like\n-\n- >>> s.sort_values(key=lambda x: (np.tan(x.cumsum())))\n- 0 -4\n- 3 2\n- 4 4\n- 1 -2\n- 2 0\n- dtype: int64\n- \"\"\"\n- inplace = validate_bool_kwarg(inplace, \"inplace\")\n- # Validate the axis parameter\n- self._get_axis_number(axis)\n-\n- # GH 5856/5853\n- if inplace and self._is_cached:\n- raise ValueError(\n- \"This Series is a view of some other array, to \"\n- \"sort in-place you must create a copy\"\n- )\n-\n- if is_list_like(ascending):\n- ascending = cast(Sequence[Union[bool, int]], ascending)\n- if len(ascending) != 1:\n- raise ValueError(\n- f\"Length of ascending ({len(ascending)}) must be 1 for Series\"\n- )\n- ascending = ascending[0]\n-\n- ascending = validate_ascending(ascending)\n-\n- if na_position not in [\"first\", \"last\"]:\n- raise ValueError(f\"invalid na_position: {na_position}\")\n-\n- # GH 35922. Make sorting stable by leveraging nargsort\n- values_to_sort = ensure_key_mapped(self, key)._values if key else self._values\n- sorted_index = nargsort(values_to_sort, kind, bool(ascending), na_position)\n-\n- result = self._constructor(\n- self._values[sorted_index], index=self.index[sorted_index]\n- )\n-\n- if ignore_index:\n- result.index = default_index(len(sorted_index))\n-\n- if inplace:\n- self._update_inplace(result)\n- else:\n- return result.__finalize__(self, method=\"sort_values\")\n-\n- @overload\n- def sort_index(\n- self,\n- *,\n- axis: Axis = ...,\n- level: Level | None = ...,\n- ascending: bool | Sequence[bool] = ...,\n- inplace: Literal[True],\n- kind: SortKind = ...,\n- na_position: NaPosition = ...,\n- sort_remaining: bool = ...,\n- ignore_index: bool = ...,\n- key: IndexKeyFunc = ...,\n- ) -> None:\n- ...\n-\n- @overload\n- def sort_index(\n- self,\n- *,\n- axis: Axis = ...,\n- level: Level | None = ...,\n- ascending: bool | Sequence[bool] = ...,\n- inplace: Literal[False] = ...,\n- kind: SortKind = ...,\n- na_position: NaPosition = ...,\n- sort_remaining: bool = ...,\n- ignore_index: bool = ...,\n- key: IndexKeyFunc = ...,\n- ) -> Series:\n- ...\n-\n- @overload\n- def sort_index(\n- self,\n- *,\n- axis: Axis = ...,\n- level: Level | None = ...,\n- ascending: bool | Sequence[bool] = ...,\n- inplace: bool = ...,\n- kind: SortKind = ...,\n- na_position: NaPosition = ...,\n- sort_remaining: bool = ...,\n- ignore_index: bool = ...,\n- key: IndexKeyFunc = ...,\n- ) -> Series | None:\n- ...\n-\n- # error: Signature of \"sort_index\" incompatible with supertype \"NDFrame\"\n- @deprecate_nonkeyword_arguments(version=None, allowed_args=[\"self\"])\n- def sort_index( # type: ignore[override]\n- self,\n- axis: Axis = 0,\n- level: Level | None = None,\n- ascending: bool | Sequence[bool] = True,\n- inplace: bool = False,\n- kind: SortKind = \"quicksort\",\n- na_position: NaPosition = \"last\",\n- sort_remaining: bool = True,\n- ignore_index: bool = False,\n- key: IndexKeyFunc = None,\n- ) -> Series | None:\n- \"\"\"\n- Sort Series by index labels.\n-\n- Returns a new Series sorted by label if `inplace` argument is\n- ``False``, otherwise updates the original series and returns None.\n-\n- Parameters\n- ----------\n- axis : {0 or 'index'}\n- Unused. Parameter needed for compatibility with DataFrame.\n- level : int, optional\n- If not None, sort on values in specified index level(s).\n- ascending : bool or list-like of bools, default True\n- Sort ascending vs. descending. When the index is a MultiIndex the\n- sort direction can be controlled for each level individually.\n- inplace : bool, default False\n- If True, perform operation in-place.\n- kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, default 'quicksort'\n- Choice of sorting algorithm. See also :func:`numpy.sort` for more\n- information. 'mergesort' and 'stable' are the only stable algorithms. For\n- DataFrames, this option is only applied when sorting on a single\n- column or label.\n- na_position : {'first', 'last'}, default 'last'\n- If 'first' puts NaNs at the beginning, 'last' puts NaNs at the end.\n- Not implemented for MultiIndex.\n- sort_remaining : bool, default True\n- If True and sorting by level and index is multilevel, sort by other\n- levels too (in order) after sorting by specified level.\n- ignore_index : bool, default False\n- If True, the resulting axis will be labeled 0, 1, …, n - 1.\n-\n- .. versionadded:: 1.0.0\n-\n- key : callable, optional\n- If not None, apply the key function to the index values\n- before sorting. This is similar to the `key` argument in the\n- builtin :meth:`sorted` function, with the notable difference that\n- this `key` function should be *vectorized*. It should expect an\n- ``Index`` and return an ``Index`` of the same shape.\n-\n- .. versionadded:: 1.1.0\n-\n- Returns\n- -------\n- Series or None\n- The original Series sorted by the labels or None if ``inplace=True``.\n-\n- See Also\n- --------\n- DataFrame.sort_index: Sort DataFrame by the index.\n- DataFrame.sort_values: Sort DataFrame by the value.\n- Series.sort_values : Sort Series by the value.\n-\n- Examples\n- --------\n- >>> s = pd.Series(['a', 'b', 'c', 'd'], index=[3, 2, 1, 4])\n- >>> s.sort_index()\n- 1 c\n- 2 b\n- 3 a\n- 4 d\n- dtype: object\n-\n- Sort Descending\n-\n- >>> s.sort_index(ascending=False)\n- 4 d\n- 3 a\n- 2 b\n- 1 c\n- dtype: object\n-\n- Sort Inplace\n-\n- >>> s.sort_index(inplace=True)\n- >>> s\n- 1 c\n- 2 b\n- 3 a\n- 4 d\n- dtype: object\n-\n- By default NaNs are put at the end, but use `na_position` to place\n- them at the beginning\n-\n- >>> s = pd.Series(['a', 'b', 'c', 'd'], index=[3, 2, 1, np.nan])\n- >>> s.sort_index(na_position='first')\n- NaN d\n- 1.0 c\n- 2.0 b\n- 3.0 a\n- dtype: object\n-\n- Specify index level to sort\n-\n- >>> arrays = [np.array(['qux', 'qux', 'foo', 'foo',\n- ... 'baz', 'baz', 'bar', 'bar']),\n- ... np.array(['two', 'one', 'two', 'one',\n- ... 'two', 'one', 'two', 'one'])]\n- >>> s = pd.Series([1, 2, 3, 4, 5, 6, 7, 8], index=arrays)\n- >>> s.sort_index(level=1)\n- bar one 8\n- baz one 6\n- foo one 4\n- qux one 2\n- bar two 7\n- baz two 5\n- foo two 3\n- qux two 1\n- dtype: int64\n-\n- Does not sort by remaining levels when sorting by levels\n-\n- >>> s.sort_index(level=1, sort_remaining=False)\n- qux one 2\n- foo one 4\n- baz one 6\n- bar one 8\n- qux two 1\n- foo two 3\n- baz two 5\n- bar two 7\n- dtype: int64\n-\n- Apply a key function before sorting\n-\n- >>> s = pd.Series([1, 2, 3, 4], index=['A', 'b', 'C', 'd'])\n- >>> s.sort_index(key=lambda x : x.str.lower())\n- A 1\n- b 2\n- C 3\n- d 4\n- dtype: int64\n- \"\"\"\n-\n- return super().sort_index(\n- axis=axis,\n- level=level,\n- ascending=ascending,\n- inplace=inplace,\n- kind=kind,\n- na_position=na_position,\n- sort_remaining=sort_remaining,\n- ignore_index=ignore_index,\n- key=key,\n- )\n-\n- def argsort(self, axis=0, kind=\"quicksort\", order=None) -> Series:\n- \"\"\"\n- Return the integer indices that would sort the Series values.\n-\n- Override ndarray.argsort. Argsorts the value, omitting NA/null values,\n- and places the result in the same locations as the non-NA values.\n-\n- Parameters\n- ----------\n- axis : {0 or 'index'}\n- Unused. Parameter needed for compatibility with DataFrame.\n- kind : {'mergesort', 'quicksort', 'heapsort', 'stable'}, default 'quicksort'\n- Choice of sorting algorithm. See :func:`numpy.sort` for more\n- information. 'mergesort' and 'stable' are the only stable algorithms.\n- order : None\n- Has no effect but is accepted for compatibility with numpy.\n-\n- Returns\n- -------\n- Series[np.intp]\n- Positions of values within the sort order with -1 indicating\n- nan values.\n-\n- See Also\n- --------\n- numpy.ndarray.argsort : Returns the indices that would sort this array.\n- \"\"\"\n- values = self._values\n- mask = isna(values)\n-\n- if mask.any():\n- result = np.full(len(self), -1, dtype=np.intp)\n- notmask = ~mask\n- result[notmask] = np.argsort(values[notmask], kind=kind)\n- else:\n- result = np.argsort(values, kind=kind)\n-\n- res = self._constructor(result, index=self.index, name=self.name, dtype=np.intp)\n- return res.__finalize__(self, method=\"argsort\")\n-\n- def nlargest(self, n=5, keep=\"first\") -> Series:\n- \"\"\"\n- Return the largest `n` elements.\n-\n- Parameters\n- ----------\n- n : int, default 5\n- Return this many descending sorted values.\n- keep : {'first', 'last', 'all'}, default 'first'\n- When there are duplicate values that cannot all fit in a\n- Series of `n` elements:\n-\n- - ``first`` : return the first `n` occurrences in order\n- of appearance.\n- - ``last`` : return the last `n` occurrences in reverse\n- order of appearance.\n- - ``all`` : keep all occurrences. This can result in a Series of\n- size larger than `n`.\n-\n- Returns\n- -------\n- Series\n- The `n` largest values in the Series, sorted in decreasing order.\n-\n- See Also\n- --------\n- Series.nsmallest: Get the `n` smallest elements.\n- Series.sort_values: Sort Series by values.\n- Series.head: Return the first `n` rows.\n-\n- Notes\n- -----\n- Faster than ``.sort_values(ascending=False).head(n)`` for small `n`\n- relative to the size of the ``Series`` object.\n-\n- Examples\n- --------\n- >>> countries_population = {\"Italy\": 59000000, \"France\": 65000000,\n- ... \"Malta\": 434000, \"Maldives\": 434000,\n- ... \"Brunei\": 434000, \"Iceland\": 337000,\n- ... \"Nauru\": 11300, \"Tuvalu\": 11300,\n- ... \"Anguilla\": 11300, \"Montserrat\": 5200}\n- >>> s = pd.Series(countries_population)\n- >>> s\n- Italy 59000000\n- France 65000000\n- Malta 434000\n- Maldives 434000\n- Brunei 434000\n- Iceland 337000\n- Nauru 11300\n- Tuvalu 11300\n- Anguilla 11300\n- Montserrat 5200\n- dtype: int64\n-\n- The `n` largest elements where ``n=5`` by default.\n-\n- >>> s.nlargest()\n- France 65000000\n- Italy 59000000\n- Malta 434000\n- Maldives 434000\n- Brunei 434000\n- dtype: int64\n-\n- The `n` largest elements where ``n=3``. Default `keep` value is 'first'\n- so Malta will be kept.\n-\n- >>> s.nlargest(3)\n- France 65000000\n- Italy 59000000\n- Malta 434000\n- dtype: int64\n-\n- The `n` largest elements where ``n=3`` and keeping the last duplicates.\n- Brunei will be kept since it is the last with value 434000 based on\n- the index order.\n-\n- >>> s.nlargest(3, keep='last')\n- France 65000000\n- Italy 59000000\n- Brunei 434000\n- dtype: int64\n-\n- The `n` largest elements where ``n=3`` with all duplicates kept. Note\n- that the returned Series has five elements due to the three duplicates.\n-\n- >>> s.nlargest(3, keep='all')\n- France 65000000\n- Italy 59000000\n- Malta 434000\n- Maldives 434000\n- Brunei 434000\n- dtype: int64\n- \"\"\"\n- return algorithms.SelectNSeries(self, n=n, keep=keep).nlargest()\n-\n- def nsmallest(self, n: int = 5, keep: str = \"first\") -> Series:\n- \"\"\"\n- Return the smallest `n` elements.\n-\n- Parameters\n- ----------\n- n : int, default 5\n- Return this many ascending sorted values.\n- keep : {'first', 'last', 'all'}, default 'first'\n- When there are duplicate values that cannot all fit in a\n- Series of `n` elements:\n-\n- - ``first`` : return the first `n` occurrences in order\n- of appearance.\n- - ``last`` : return the last `n` occurrences in reverse\n- order of appearance.\n- - ``all`` : keep all occurrences. This can result in a Series of\n- size larger than `n`.\n-\n- Returns\n- -------\n- Series\n- The `n` smallest values in the Series, sorted in increasing order.\n-\n- See Also\n- --------\n- Series.nlargest: Get the `n` largest elements.\n- Series.sort_values: Sort Series by values.\n- Series.head: Return the first `n` rows.\n-\n- Notes\n- -----\n- Faster than ``.sort_values().head(n)`` for small `n` relative to\n- the size of the ``Series`` object.\n-\n- Examples\n- --------\n- >>> countries_population = {\"Italy\": 59000000, \"France\": 65000000,\n- ... \"Brunei\": 434000, \"Malta\": 434000,\n- ... \"Maldives\": 434000, \"Iceland\": 337000,\n- ... \"Nauru\": 11300, \"Tuvalu\": 11300,\n- ... \"Anguilla\": 11300, \"Montserrat\": 5200}\n- >>> s = pd.Series(countries_population)\n- >>> s\n- Italy 59000000\n- France 65000000\n- Brunei 434000\n- Malta 434000\n- Maldives 434000\n- Iceland 337000\n- Nauru 11300\n- Tuvalu 11300\n- Anguilla 11300\n- Montserrat 5200\n- dtype: int64\n-\n- The `n` smallest elements where ``n=5`` by default.\n-\n- >>> s.nsmallest()\n- Montserrat 5200\n- Nauru 11300\n- Tuvalu 11300\n- Anguilla 11300\n- Iceland 337000\n- dtype: int64\n-\n- The `n` smallest elements where ``n=3``. Default `keep` value is\n- 'first' so Nauru and Tuvalu will be kept.\n-\n- >>> s.nsmallest(3)\n- Montserrat 5200\n- Nauru 11300\n- Tuvalu 11300\n- dtype: int64\n-\n- The `n` smallest elements where ``n=3`` and keeping the last\n- duplicates. Anguilla and Tuvalu will be kept since they are the last\n- with value 11300 based on the index order.\n-\n- >>> s.nsmallest(3, keep='last')\n- Montserrat 5200\n- Anguilla 11300\n- Tuvalu 11300\n- dtype: int64\n-\n- The `n` smallest elements where ``n=3`` with all duplicates kept. Note\n- that the returned Series has four elements due to the three duplicates.\n-\n- >>> s.nsmallest(3, keep='all')\n- Montserrat 5200\n- Nauru 11300\n- Tuvalu 11300\n- Anguilla 11300\n- dtype: int64\n- \"\"\"\n- return algorithms.SelectNSeries(self, n=n, keep=keep).nsmallest()\n-\n- @doc(\n- klass=_shared_doc_kwargs[\"klass\"],\n- extra_params=dedent(\n- \"\"\"copy : bool, default True\n- Whether to copy underlying data.\"\"\"\n- ),\n- examples=dedent(\n- \"\"\"\\\n- Examples\n- --------\n- >>> s = pd.Series(\n- ... [\"A\", \"B\", \"A\", \"C\"],\n- ... index=[\n- ... [\"Final exam\", \"Final exam\", \"Coursework\", \"Coursework\"],\n- ... [\"History\", \"Geography\", \"History\", \"Geography\"],\n- ... [\"January\", \"February\", \"March\", \"April\"],\n- ... ],\n- ... )\n- >>> s\n- Final exam History January A\n- Geography February B\n- Coursework History March A\n- Geography April C\n- dtype: object\n-\n- In the following example, we will swap the levels of the indices.\n- Here, we will swap the levels column-wise, but levels can be swapped row-wise\n- in a similar manner. Note that column-wise is the default behaviour.\n- By not supplying any arguments for i and j, we swap the last and second to\n- last indices.\n-\n- >>> s.swaplevel()\n- Final exam January History A\n- February Geography B\n- Coursework March History A\n- April Geography C\n- dtype: object\n-\n- By supplying one argument, we can choose which index to swap the last\n- index with. We can for example swap the first index with the last one as\n- follows.\n-\n- >>> s.swaplevel(0)\n- January History Final exam A\n- February Geography Final exam B\n- March History Coursework A\n- April Geography Coursework C\n- dtype: object\n-\n- We can also define explicitly which indices we want to swap by supplying values\n- for both i and j. Here, we for example swap the first and second indices.\n-\n- >>> s.swaplevel(0, 1)\n- History Final exam January A\n- Geography Final exam February B\n- History Coursework March A\n- Geography Coursework April C\n- dtype: object\"\"\"\n- ),\n- )\n- def swaplevel(self, i=-2, j=-1, copy=True) -> Series:\n- \"\"\"\n- Swap levels i and j in a :class:`MultiIndex`.\n-\n- Default is to swap the two innermost levels of the index.\n-\n- Parameters\n- ----------\n- i, j : int or str\n- Levels of the indices to be swapped. Can pass level name as string.\n- {extra_params}\n-\n- Returns\n- -------\n- {klass}\n- {klass} with levels swapped in MultiIndex.\n-\n- {examples}\n- \"\"\"\n- assert isinstance(self.index, MultiIndex)\n- new_index = self.index.swaplevel(i, j)\n- return self._constructor(self._values, index=new_index, copy=copy).__finalize__(\n- self, method=\"swaplevel\"\n- )\n-\n- def reorder_levels(self, order) -> Series:\n- \"\"\"\n- Rearrange index levels using input order.\n-\n- May not drop or duplicate levels.\n-\n- Parameters\n- ----------\n- order : list of int representing new level order\n- Reference level by number or key.\n-\n- Returns\n- -------\n- type of caller (new object)\n- \"\"\"\n- if not isinstance(self.index, MultiIndex): # pragma: no cover\n- raise Exception(\"Can only reorder levels on a hierarchical axis.\")\n-\n- result = self.copy()\n- assert isinstance(result.index, MultiIndex)\n- result.index = result.index.reorder_levels(order)\n- return result\n-\n- def explode(self, ignore_index: bool = False) -> Series:\n- \"\"\"\n- Transform each element of a list-like to a row.\n-\n- .. versionadded:: 0.25.0\n-\n- Parameters\n- ----------\n- ignore_index : bool, default False\n- If True, the resulting index will be labeled 0, 1, …, n - 1.\n-\n- .. versionadded:: 1.1.0\n-\n- Returns\n- -------\n- Series\n- Exploded lists to rows; index will be duplicated for these rows.\n-\n- See Also\n- --------\n- Series.str.split : Split string values on specified separator.\n- Series.unstack : Unstack, a.k.a. pivot, Series with MultiIndex\n- to produce DataFrame.\n- DataFrame.melt : Unpivot a DataFrame from wide format to long format.\n- DataFrame.explode : Explode a DataFrame from list-like\n- columns to long format.\n-\n- Notes\n- -----\n- This routine will explode list-likes including lists, tuples, sets,\n- Series, and np.ndarray. The result dtype of the subset rows will\n- be object. Scalars will be returned unchanged, and empty list-likes will\n- result in a np.nan for that row. In addition, the ordering of elements in\n- the output will be non-deterministic when exploding sets.\n-\n- Reference :ref:`the user guide <reshaping.explode>` for more examples.\n-\n- Examples\n- --------\n- >>> s = pd.Series([[1, 2, 3], 'foo', [], [3, 4]])\n- >>> s\n- 0 [1, 2, 3]\n- 1 foo\n- 2 []\n- 3 [3, 4]\n- dtype: object\n-\n- >>> s.explode()\n- 0 1\n- 0 2\n- 0 3\n- 1 foo\n- 2 NaN\n- 3 3\n- 3 4\n- dtype: object\n- \"\"\"\n- if not len(self) or not is_object_dtype(self):\n- result = self.copy()\n- return result.reset_index(drop=True) if ignore_index else result\n-\n- values, counts = reshape.explode(np.asarray(self._values))\n-\n- if ignore_index:\n- index = default_index(len(values))\n- else:\n- index = self.index.repeat(counts)\n-\n- return self._constructor(values, index=index, name=self.name)\n-\n- def unstack(self, level=-1, fill_value=None) -> DataFrame:\n- \"\"\"\n- Unstack, also known as pivot, Series with MultiIndex to produce DataFrame.\n-\n- Parameters\n- ----------\n- level : int, str, or list of these, default last level\n- Level(s) to unstack, can pass level name.\n- fill_value : scalar value, default None\n- Value to use when replacing NaN values.\n-\n- Returns\n- -------\n- DataFrame\n- Unstacked Series.\n-\n- Notes\n- -----\n- Reference :ref:`the user guide <reshaping.stacking>` for more examples.\n-\n- Examples\n- --------\n- >>> s = pd.Series([1, 2, 3, 4],\n- ... index=pd.MultiIndex.from_product([['one', 'two'],\n- ... ['a', 'b']]))\n- >>> s\n- one a 1\n- b 2\n- two a 3\n- b 4\n- dtype: int64\n-\n- >>> s.unstack(level=-1)\n- a b\n- one 1 2\n- two 3 4\n-\n- >>> s.unstack(level=0)\n- one two\n- a 1 3\n- b 2 4\n- \"\"\"\n- from pandas.core.reshape.reshape import unstack\n-\n- return unstack(self, level, fill_value)\n-\n- # ----------------------------------------------------------------------\n- # function application\n-\n- def map(self, arg, na_action=None) -> Series:\n- \"\"\"\n- Map values of Series according to an input mapping or function.\n-\n- Used for substituting each value in a Series with another value,\n- that may be derived from a function, a ``dict`` or\n- a :class:`Series`.\n-\n- Parameters\n- ----------\n- arg : function, collections.abc.Mapping subclass or Series\n- Mapping correspondence.\n- na_action : {None, 'ignore'}, default None\n- If 'ignore', propagate NaN values, without passing them to the\n- mapping correspondence.\n-\n- Returns\n- -------\n- Series\n- Same index as caller.\n-\n- See Also\n- --------\n- Series.apply : For applying more complex functions on a Series.\n- DataFrame.apply : Apply a function row-/column-wise.\n- DataFrame.applymap : Apply a function elementwise on a whole DataFrame.\n-\n- Notes\n- -----\n- When ``arg`` is a dictionary, values in Series that are not in the\n- dictionary (as keys) are converted to ``NaN``. However, if the\n- dictionary is a ``dict`` subclass that defines ``__missing__`` (i.e.\n- provides a method for default values), then this default is used\n- rather than ``NaN``.\n-\n- Examples\n- --------\n- >>> s = pd.Series(['cat', 'dog', np.nan, 'rabbit'])\n- >>> s\n- 0 cat\n- 1 dog\n- 2 NaN\n- 3 rabbit\n- dtype: object\n-\n- ``map`` accepts a ``dict`` or a ``Series``. Values that are not found\n- in the ``dict`` are converted to ``NaN``, unless the dict has a default\n- value (e.g. ``defaultdict``):\n-\n- >>> s.map({'cat': 'kitten', 'dog': 'puppy'})\n- 0 kitten\n- 1 puppy\n- 2 NaN\n- 3 NaN\n- dtype: object\n-\n- It also accepts a function:\n-\n- >>> s.map('I am a {}'.format)\n- 0 I am a cat\n- 1 I am a dog\n- 2 I am a nan\n- 3 I am a rabbit\n- dtype: object\n-\n- To avoid applying the function to missing values (and keep them as\n- ``NaN``) ``na_action='ignore'`` can be used:\n-\n- >>> s.map('I am a {}'.format, na_action='ignore')\n- 0 I am a cat\n- 1 I am a dog\n- 2 NaN\n- 3 I am a rabbit\n- dtype: object\n- \"\"\"\n- new_values = self._map_values(arg, na_action=na_action)\n- return self._constructor(new_values, index=self.index).__finalize__(\n- self, method=\"map\"\n- )\n-\n- def _gotitem(self, key, ndim, subset=None) -> Series:\n- \"\"\"\n- Sub-classes to define. Return a sliced object.\n-\n- Parameters\n- ----------\n- key : string / list of selections\n- ndim : {1, 2}\n- Requested ndim of result.\n- subset : object, default None\n- Subset to act on.\n- \"\"\"\n- return self\n-\n- _agg_see_also_doc = dedent(\n- \"\"\"\n- See Also\n- --------\n- Series.apply : Invoke function on a Series.\n- Series.transform : Transform function producing a Series with like indexes.\n- \"\"\"\n- )\n-\n- _agg_examples_doc = dedent(\n- \"\"\"\n- Examples\n- --------\n- >>> s = pd.Series([1, 2, 3, 4])\n- >>> s\n- 0 1\n- 1 2\n- 2 3\n- 3 4\n- dtype: int64\n-\n- >>> s.agg('min')\n- 1\n-\n- >>> s.agg(['min', 'max'])\n- min 1\n- max 4\n- dtype: int64\n- \"\"\"\n- )\n-\n- @doc(\n- _shared_docs[\"aggregate\"],\n- klass=_shared_doc_kwargs[\"klass\"],\n- axis=_shared_doc_kwargs[\"axis\"],\n- see_also=_agg_see_also_doc,\n- examples=_agg_examples_doc,\n- )\n- def aggregate(self, func=None, axis=0, *args, **kwargs):\n- # Validate the axis parameter\n- self._get_axis_number(axis)\n-\n- # if func is None, will switch to user-provided \"named aggregation\" kwargs\n- if func is None:\n- func = dict(kwargs.items())\n-\n- op = SeriesApply(self, func, convert_dtype=False, args=args, kwargs=kwargs)\n- result = op.agg()\n- return result\n-\n- agg = aggregate\n-\n- # error: Signature of \"any\" incompatible with supertype \"NDFrame\" [override]\n- @overload # type: ignore[override]\n- def any(\n- self,\n- *,\n- axis: Axis = ...,\n- bool_only: bool | None = ...,\n- skipna: bool = ...,\n- level: None = ...,\n- **kwargs,\n- ) -> bool:\n- ...\n-\n- @overload\n- def any(\n- self,\n- *,\n- axis: Axis = ...,\n- bool_only: bool | None = ...,\n- skipna: bool = ...,\n- level: Level,\n- **kwargs,\n- ) -> Series | bool:\n- ...\n-\n- @doc(NDFrame.any, **_shared_doc_kwargs)\n- def any(\n- self,\n- axis: Axis = 0,\n- bool_only: bool | None = None,\n- skipna: bool = True,\n- level: Level | None = None,\n- **kwargs,\n- ) -> Series | bool:\n- ...\n-\n- @doc(\n- _shared_docs[\"transform\"],\n- klass=_shared_doc_kwargs[\"klass\"],\n- axis=_shared_doc_kwargs[\"axis\"],\n- )\n- def transform(\n- self, func: AggFuncType, axis: Axis = 0, *args, **kwargs\n- ) -> DataFrame | Series:\n- # Validate axis argument\n- self._get_axis_number(axis)\n- result = SeriesApply(\n- self, func=func, convert_dtype=True, args=args, kwargs=kwargs\n- ).transform()\n- return result\n-\n- def apply(\n- self,\n- func: AggFuncType,\n- convert_dtype: bool = True,\n- args: tuple[Any, ...] = (),\n- **kwargs,\n- ) -> DataFrame | Series:\n- \"\"\"\n- Invoke function on values of Series.\n-\n- Can be ufunc (a NumPy function that applies to the entire Series)\n- or a Python function that only works on single values.\n-\n- Parameters\n- ----------\n- func : function\n- Python function or NumPy ufunc to apply.\n- convert_dtype : bool, default True\n- Try to find better dtype for elementwise function results. If\n- False, leave as dtype=object. Note that the dtype is always\n- preserved for some extension array dtypes, such as Categorical.\n- args : tuple\n- Positional arguments passed to func after the series value.\n- **kwargs\n- Additional keyword arguments passed to func.\n-\n- Returns\n- -------\n- Series or DataFrame\n- If func returns a Series object the result will be a DataFrame.\n-\n- See Also\n- --------\n- Series.map: For element-wise operations.\n- Series.agg: Only perform aggregating type operations.\n- Series.transform: Only perform transforming type operations.\n-\n- Notes\n- -----\n- Functions that mutate the passed object can produce unexpected\n- behavior or errors and are not supported. See :ref:`gotchas.udf-mutation`\n- for more details.\n-\n- Examples\n- --------\n- Create a series with typical summer temperatures for each city.\n-\n- >>> s = pd.Series([20, 21, 12],\n- ... index=['London', 'New York', 'Helsinki'])\n- >>> s\n- London 20\n- New York 21\n- Helsinki 12\n- dtype: int64\n-\n- Square the values by defining a function and passing it as an\n- argument to ``apply()``.\n-\n- >>> def square(x):\n- ... return x ** 2\n- >>> s.apply(square)\n- London 400\n- New York 441\n- Helsinki 144\n- dtype: int64\n-\n- Square the values by passing an anonymous function as an\n- argument to ``apply()``.\n-\n- >>> s.apply(lambda x: x ** 2)\n- London 400\n- New York 441\n- Helsinki 144\n- dtype: int64\n-\n- Define a custom function that needs additional positional\n- arguments and pass these additional arguments using the\n- ``args`` keyword.\n-\n- >>> def subtract_custom_value(x, custom_value):\n- ... return x - custom_value\n-\n- >>> s.apply(subtract_custom_value, args=(5,))\n- London 15\n- New York 16\n- Helsinki 7\n- dtype: int64\n-\n- Define a custom function that takes keyword arguments\n- and pass these arguments to ``apply``.\n-\n- >>> def add_custom_values(x, **kwargs):\n- ... for month in kwargs:\n- ... x += kwargs[month]\n- ... return x\n-\n- >>> s.apply(add_custom_values, june=30, july=20, august=25)\n- London 95\n- New York 96\n- Helsinki 87\n- dtype: int64\n-\n- Use a function from the Numpy library.\n-\n- >>> s.apply(np.log)\n- London 2.995732\n- New York 3.044522\n- Helsinki 2.484907\n- dtype: float64\n- \"\"\"\n- return SeriesApply(self, func, convert_dtype, args, kwargs).apply()\n-\n- def _reduce(\n- self,\n- op,\n- name: str,\n- *,\n- axis=0,\n- skipna=True,\n- numeric_only=None,\n- filter_type=None,\n- **kwds,\n- ):\n- \"\"\"\n- Perform a reduction operation.\n-\n- If we have an ndarray as a value, then simply perform the operation,\n- otherwise delegate to the object.\n- \"\"\"\n- delegate = self._values\n-\n- if axis is not None:\n- self._get_axis_number(axis)\n-\n- if isinstance(delegate, ExtensionArray):\n- # dispatch to ExtensionArray interface\n- return delegate._reduce(name, skipna=skipna, **kwds)\n-\n- else:\n- # dispatch to numpy arrays\n- if numeric_only:\n- kwd_name = \"numeric_only\"\n- if name in [\"any\", \"all\"]:\n- kwd_name = \"bool_only\"\n- raise NotImplementedError(\n- f\"Series.{name} does not implement {kwd_name}.\"\n- )\n- with np.errstate(all=\"ignore\"):\n- return op(delegate, skipna=skipna, **kwds)\n-\n- def _reindex_indexer(\n- self, new_index: Index | None, indexer: npt.NDArray[np.intp] | None, copy: bool\n- ) -> Series:\n- # Note: new_index is None iff indexer is None\n- # if not None, indexer is np.intp\n- if indexer is None and (\n- new_index is None or new_index.names == self.index.names\n- ):\n- if copy:\n- return self.copy()\n- return self\n-\n- new_values = algorithms.take_nd(\n- self._values, indexer, allow_fill=True, fill_value=None\n- )\n- return self._constructor(new_values, index=new_index)\n-\n- def _needs_reindex_multi(self, axes, method, level) -> bool:\n- \"\"\"\n- Check if we do need a multi reindex; this is for compat with\n- higher dims.\n- \"\"\"\n- return False\n-\n- # error: Cannot determine type of 'align'\n- @doc(\n- NDFrame.align, # type: ignore[has-type]\n- klass=_shared_doc_kwargs[\"klass\"],\n- axes_single_arg=_shared_doc_kwargs[\"axes_single_arg\"],\n- )\n- def align(\n- self,\n- other,\n- join=\"outer\",\n- axis=None,\n- level=None,\n- copy=True,\n- fill_value=None,\n- method=None,\n- limit=None,\n- fill_axis=0,\n- broadcast_axis=None,\n- ):\n- return super().align(\n- other,\n- join=join,\n- axis=axis,\n- level=level,\n- copy=copy,\n- fill_value=fill_value,\n- method=method,\n- limit=limit,\n- fill_axis=fill_axis,\n- broadcast_axis=broadcast_axis,\n- )\n-\n- @overload\n- def rename(\n- self,\n- index: Renamer | Hashable | None = ...,\n- *,\n- axis: Axis | None = ...,\n- copy: bool = ...,\n- inplace: Literal[True],\n- level: Level | None = ...,\n- errors: IgnoreRaise = ...,\n- ) -> None:\n- ...\n-\n- @overload\n- def rename(\n- self,\n- index: Renamer | Hashable | None = ...,\n- *,\n- axis: Axis | None = ...,\n- copy: bool = ...,\n- inplace: Literal[False] = ...,\n- level: Level | None = ...,\n- errors: IgnoreRaise = ...,\n- ) -> Series:\n- ...\n-\n- @overload\n- def rename(\n- self,\n- index: Renamer | Hashable | None = ...,\n- *,\n- axis: Axis | None = ...,\n- copy: bool = ...,\n- inplace: bool = ...,\n- level: Level | None = ...,\n- errors: IgnoreRaise = ...,\n- ) -> Series | None:\n- ...\n-\n- def rename(\n- self,\n- index: Renamer | Hashable | None = None,\n- *,\n- axis: Axis | None = None,\n- copy: bool = True,\n- inplace: bool = False,\n- level: Level | None = None,\n- errors: IgnoreRaise = \"ignore\",\n- ) -> Series | None:\n- \"\"\"\n- Alter Series index labels or name.\n-\n- Function / dict values must be unique (1-to-1). Labels not contained in\n- a dict / Series will be left as-is. Extra labels listed don't throw an\n- error.\n-\n- Alternatively, change ``Series.name`` with a scalar value.\n-\n- See the :ref:`user guide <basics.rename>` for more.\n-\n- Parameters\n- ----------\n- axis : {0 or 'index'}\n- Unused. Parameter needed for compatibility with DataFrame.\n- index : scalar, hashable sequence, dict-like or function, optional\n- Functions or dict-like are transformations to apply to\n- the index.\n- Scalar or hashable sequence-like will alter the ``Series.name``\n- attribute.\n-\n- **kwargs\n- Additional keyword arguments passed to the function. Only the\n- \"inplace\" keyword is used.\n-\n- Returns\n- -------\n- Series or None\n- Series with index labels or name altered or None if ``inplace=True``.\n-\n- See Also\n- --------\n- DataFrame.rename : Corresponding DataFrame method.\n- Series.rename_axis : Set the name of the axis.\n-\n- Examples\n- --------\n- >>> s = pd.Series([1, 2, 3])\n- >>> s\n- 0 1\n- 1 2\n- 2 3\n- dtype: int64\n- >>> s.rename(\"my_name\") # scalar, changes Series.name\n- 0 1\n- 1 2\n- 2 3\n- Name: my_name, dtype: int64\n- >>> s.rename(lambda x: x ** 2) # function, changes labels\n- 0 1\n- 1 2\n- 4 3\n- dtype: int64\n- >>> s.rename({1: 3, 2: 5}) # mapping, changes labels\n- 0 1\n- 3 2\n- 5 3\n- dtype: int64\n- \"\"\"\n- if axis is not None:\n- # Make sure we raise if an invalid 'axis' is passed.\n- axis = self._get_axis_number(axis)\n-\n- if callable(index) or is_dict_like(index):\n- # error: Argument 1 to \"_rename\" of \"NDFrame\" has incompatible\n- # type \"Union[Union[Mapping[Any, Hashable], Callable[[Any],\n- # Hashable]], Hashable, None]\"; expected \"Union[Mapping[Any,\n- # Hashable], Callable[[Any], Hashable], None]\"\n- return super()._rename(\n- index, # type: ignore[arg-type]\n- copy=copy,\n- inplace=inplace,\n- level=level,\n- errors=errors,\n- )\n- else:\n- return self._set_name(index, inplace=inplace)\n-\n- @overload\n- def set_axis(\n- self, labels, axis: Axis = ..., inplace: Literal[False] = ...\n- ) -> Series:\n- ...\n-\n- @overload\n- def set_axis(self, labels, axis: Axis, inplace: Literal[True]) -> None:\n- ...\n-\n- @overload\n- def set_axis(self, labels, *, inplace: Literal[True]) -> None:\n- ...\n-\n- @overload\n- def set_axis(self, labels, axis: Axis = ..., inplace: bool = ...) -> Series | None:\n- ...\n-\n- @deprecate_nonkeyword_arguments(version=None, allowed_args=[\"self\", \"labels\"])\n- @Appender(\n- \"\"\"\n- Examples\n- --------\n- >>> s = pd.Series([1, 2, 3])\n- >>> s\n- 0 1\n- 1 2\n- 2 3\n- dtype: int64\n-\n- >>> s.set_axis(['a', 'b', 'c'], axis=0)\n- a 1\n- b 2\n- c 3\n- dtype: int64\n- \"\"\"\n- )\n- @Substitution(\n- **_shared_doc_kwargs,\n- extended_summary_sub=\"\",\n- axis_description_sub=\"\",\n- see_also_sub=\"\",\n- )\n- @Appender(NDFrame.set_axis.__doc__)\n- def set_axis(self, labels, axis: Axis = 0, inplace: bool = False):\n- return super().set_axis(labels, axis=axis, inplace=inplace)\n-\n- # error: Cannot determine type of 'reindex'\n- @doc(\n- NDFrame.reindex, # type: ignore[has-type]\n- klass=_shared_doc_kwargs[\"klass\"],\n- axes=_shared_doc_kwargs[\"axes\"],\n- optional_labels=_shared_doc_kwargs[\"optional_labels\"],\n- optional_axis=_shared_doc_kwargs[\"optional_axis\"],\n- )\n- def reindex(self, *args, **kwargs) -> Series:\n- if len(args) > 1:\n- raise TypeError(\"Only one positional argument ('index') is allowed\")\n- if args:\n- (index,) = args\n- if \"index\" in kwargs:\n- raise TypeError(\n- \"'index' passed as both positional and keyword argument\"\n- )\n- kwargs.update({\"index\": index})\n- return super().reindex(**kwargs)\n-\n- @overload\n- def drop(\n- self,\n- labels: Hashable | list[Hashable] = ...,\n- *,\n- axis: Axis = ...,\n- index: Hashable | list[Hashable] = ...,\n- columns: Hashable | list[Hashable] = ...,\n- level: Level | None = ...,\n- inplace: Literal[True],\n- errors: IgnoreRaise = ...,\n- ) -> None:\n- ...\n-\n- @overload\n- def drop(\n- self,\n- labels: Hashable | list[Hashable] = ...,\n- *,\n- axis: Axis = ...,\n- index: Hashable | list[Hashable] = ...,\n- columns: Hashable | list[Hashable] = ...,\n- level: Level | None = ...,\n- inplace: Literal[False] = ...,\n- errors: IgnoreRaise = ...,\n- ) -> Series:\n- ...\n-\n- @overload\n- def drop(\n- self,\n- labels: Hashable | list[Hashable] = ...,\n- *,\n- axis: Axis = ...,\n- index: Hashable | list[Hashable] = ...,\n- columns: Hashable | list[Hashable] = ...,\n- level: Level | None = ...,\n- inplace: bool = ...,\n- errors: IgnoreRaise = ...,\n- ) -> Series | None:\n- ...\n-\n- # error: Signature of \"drop\" incompatible with supertype \"NDFrame\"\n- # github.com/python/mypy/issues/12387\n- @deprecate_nonkeyword_arguments(version=None, allowed_args=[\"self\", \"labels\"])\n- def drop( # type: ignore[override]\n- self,\n- labels: Hashable | list[Hashable] = None,\n- axis: Axis = 0,\n- index: Hashable | list[Hashable] = None,\n- columns: Hashable | list[Hashable] = None,\n- level: Level | None = None,\n- inplace: bool = False,\n- errors: IgnoreRaise = \"raise\",\n- ) -> Series | None:\n- \"\"\"\n- Return Series with specified index labels removed.\n-\n- Remove elements of a Series based on specifying the index labels.\n- When using a multi-index, labels on different levels can be removed\n- by specifying the level.\n-\n- Parameters\n- ----------\n- labels : single label or list-like\n- Index labels to drop.\n- axis : {0 or 'index'}\n- Unused. Parameter needed for compatibility with DataFrame.\n- index : single label or list-like\n- Redundant for application on Series, but 'index' can be used instead\n- of 'labels'.\n- columns : single label or list-like\n- No change is made to the Series; use 'index' or 'labels' instead.\n- level : int or level name, optional\n- For MultiIndex, level for which the labels will be removed.\n- inplace : bool, default False\n- If True, do operation inplace and return None.\n- errors : {'ignore', 'raise'}, default 'raise'\n- If 'ignore', suppress error and only existing labels are dropped.\n-\n- Returns\n- -------\n- Series or None\n- Series with specified index labels removed or None if ``inplace=True``.\n-\n- Raises\n- ------\n- KeyError\n- If none of the labels are found in the index.\n-\n- See Also\n- --------\n- Series.reindex : Return only specified index labels of Series.\n- Series.dropna : Return series without null values.\n- Series.drop_duplicates : Return Series with duplicate values removed.\n- DataFrame.drop : Drop specified labels from rows or columns.\n-\n- Examples\n- --------\n- >>> s = pd.Series(data=np.arange(3), index=['A', 'B', 'C'])\n- >>> s\n- A 0\n- B 1\n- C 2\n- dtype: int64\n-\n- Drop labels B en C\n-\n- >>> s.drop(labels=['B', 'C'])\n- A 0\n- dtype: int64\n-\n- Drop 2nd level label in MultiIndex Series\n-\n- >>> midx = pd.MultiIndex(levels=[['lama', 'cow', 'falcon'],\n- ... ['speed', 'weight', 'length']],\n- ... codes=[[0, 0, 0, 1, 1, 1, 2, 2, 2],\n- ... [0, 1, 2, 0, 1, 2, 0, 1, 2]])\n- >>> s = pd.Series([45, 200, 1.2, 30, 250, 1.5, 320, 1, 0.3],\n- ... index=midx)\n- >>> s\n- lama speed 45.0\n- weight 200.0\n- length 1.2\n- cow speed 30.0\n- weight 250.0\n- length 1.5\n- falcon speed 320.0\n- weight 1.0\n- length 0.3\n- dtype: float64\n-\n- >>> s.drop(labels='weight', level=1)\n- lama speed 45.0\n- length 1.2\n- cow speed 30.0\n- length 1.5\n- falcon speed 320.0\n- length 0.3\n- dtype: float64\n- \"\"\"\n- return super().drop(\n- labels=labels,\n- axis=axis,\n- index=index,\n- columns=columns,\n- level=level,\n- inplace=inplace,\n- errors=errors,\n- )\n-\n- @overload\n- def fillna(\n- self,\n- value=...,\n- method: FillnaOptions | None = ...,\n- axis: Axis | None = ...,\n- inplace: Literal[False] = ...,\n- limit=...,\n- downcast=...,\n- ) -> Series:\n- ...\n-\n- @overload\n- def fillna(\n- self,\n- value,\n- method: FillnaOptions | None,\n- axis: Axis | None,\n- inplace: Literal[True],\n- limit=...,\n- downcast=...,\n- ) -> None:\n- ...\n-\n- @overload\n- def fillna(\n- self,\n- *,\n- inplace: Literal[True],\n- limit=...,\n- downcast=...,\n- ) -> None:\n- ...\n-\n- @overload\n- def fillna(\n- self,\n- value,\n- *,\n- inplace: Literal[True],\n- limit=...,\n- downcast=...,\n- ) -> None:\n- ...\n-\n- @overload\n- def fillna(\n- self,\n- *,\n- method: FillnaOptions | None,\n- inplace: Literal[True],\n- limit=...,\n- downcast=...,\n- ) -> None:\n- ...\n-\n- @overload\n- def fillna(\n- self,\n- *,\n- axis: Axis | None,\n- inplace: Literal[True],\n- limit=...,\n- downcast=...,\n- ) -> None:\n- ...\n-\n- @overload\n- def fillna(\n- self,\n- *,\n- method: FillnaOptions | None,\n- axis: Axis | None,\n- inplace: Literal[True],\n- limit=...,\n- downcast=...,\n- ) -> None:\n- ...\n-\n- @overload\n- def fillna(\n- self,\n- value,\n- *,\n- axis: Axis | None,\n- inplace: Literal[True],\n- limit=...,\n- downcast=...,\n- ) -> None:\n- ...\n-\n- @overload\n- def fillna(\n- self,\n- value,\n- method: FillnaOptions | None,\n- *,\n- inplace: Literal[True],\n- limit=...,\n- downcast=...,\n- ) -> None:\n- ...\n-\n- @overload\n- def fillna(\n- self,\n- value=...,\n- method: FillnaOptions | None = ...,\n- axis: Axis | None = ...,\n- inplace: bool = ...,\n- limit=...,\n- downcast=...,\n- ) -> Series | None:\n- ...\n-\n- # error: Cannot determine type of 'fillna'\n- @deprecate_nonkeyword_arguments(version=None, allowed_args=[\"self\", \"value\"])\n- @doc(NDFrame.fillna, **_shared_doc_kwargs) # type: ignore[has-type]\n- def fillna(\n- self,\n- value: object | ArrayLike | None = None,\n- method: FillnaOptions | None = None,\n- axis=None,\n- inplace=False,\n- limit=None,\n- downcast=None,\n- ) -> Series | None:\n- return super().fillna(\n- value=value,\n- method=method,\n- axis=axis,\n- inplace=inplace,\n- limit=limit,\n- downcast=downcast,\n- )\n-\n- def pop(self, item: Hashable) -> Any:\n- \"\"\"\n- Return item and drops from series. Raise KeyError if not found.\n-\n- Parameters\n- ----------\n- item : label\n- Index of the element that needs to be removed.\n-\n- Returns\n- -------\n- Value that is popped from series.\n-\n- Examples\n- --------\n- >>> ser = pd.Series([1,2,3])\n-\n- >>> ser.pop(0)\n- 1\n-\n- >>> ser\n- 1 2\n- 2 3\n- dtype: int64\n- \"\"\"\n- return super().pop(item=item)\n-\n- # error: Cannot determine type of 'replace'\n- @doc(\n- NDFrame.replace, # type: ignore[has-type]\n- klass=_shared_doc_kwargs[\"klass\"],\n- inplace=_shared_doc_kwargs[\"inplace\"],\n- replace_iloc=_shared_doc_kwargs[\"replace_iloc\"],\n- )\n- def replace(\n- self,\n- to_replace=None,\n- value=lib.no_default,\n- inplace=False,\n- limit=None,\n- regex=False,\n- method: str | lib.NoDefault = lib.no_default,\n- ):\n- return super().replace(\n- to_replace=to_replace,\n- value=value,\n- inplace=inplace,\n- limit=limit,\n- regex=regex,\n- method=method,\n- )\n-\n- @doc(INFO_DOCSTRING, **series_sub_kwargs)\n- def info(\n- self,\n- verbose: bool | None = None,\n- buf: IO[str] | None = None,\n- max_cols: int | None = None,\n- memory_usage: bool | str | None = None,\n- show_counts: bool = True,\n- ) -> None:\n- return SeriesInfo(self, memory_usage).render(\n- buf=buf,\n- max_cols=max_cols,\n- verbose=verbose,\n- show_counts=show_counts,\n- )\n-\n- def _replace_single(self, to_replace, method: str, inplace: bool, limit):\n- \"\"\"\n- Replaces values in a Series using the fill method specified when no\n- replacement value is given in the replace method\n- \"\"\"\n-\n- result = self if inplace else self.copy()\n-\n- values = result._values\n- mask = missing.mask_missing(values, to_replace)\n-\n- if isinstance(values, ExtensionArray):\n- # dispatch to the EA's _pad_mask_inplace method\n- values._fill_mask_inplace(method, limit, mask)\n- else:\n- fill_f = missing.get_fill_func(method)\n- fill_f(values, limit=limit, mask=mask)\n-\n- if inplace:\n- return\n- return result\n-\n- # error: Cannot determine type of 'shift'\n- @doc(NDFrame.shift, klass=_shared_doc_kwargs[\"klass\"]) # type: ignore[has-type]\n- def shift(self, periods=1, freq=None, axis=0, fill_value=None) -> Series:\n- return super().shift(\n- periods=periods, freq=freq, axis=axis, fill_value=fill_value\n- )\n-\n- def memory_usage(self, index: bool = True, deep: bool = False) -> int:\n- \"\"\"\n- Return the memory usage of the Series.\n-\n- The memory usage can optionally include the contribution of\n- the index and of elements of `object` dtype.\n-\n- Parameters\n- ----------\n- index : bool, default True\n- Specifies whether to include the memory usage of the Series index.\n- deep : bool, default False\n- If True, introspect the data deeply by interrogating\n- `object` dtypes for system-level memory consumption, and include\n- it in the returned value.\n-\n- Returns\n- -------\n- int\n- Bytes of memory consumed.\n-\n- See Also\n- --------\n- numpy.ndarray.nbytes : Total bytes consumed by the elements of the\n- array.\n- DataFrame.memory_usage : Bytes consumed by a DataFrame.\n-\n- Examples\n- --------\n- >>> s = pd.Series(range(3))\n- >>> s.memory_usage()\n- 152\n-\n- Not including the index gives the size of the rest of the data, which\n- is necessarily smaller:\n-\n- >>> s.memory_usage(index=False)\n- 24\n-\n- The memory footprint of `object` values is ignored by default:\n-\n- >>> s = pd.Series([\"a\", \"b\"])\n- >>> s.values\n- array(['a', 'b'], dtype=object)\n- >>> s.memory_usage()\n- 144\n- >>> s.memory_usage(deep=True)\n- 244\n- \"\"\"\n- v = self._memory_usage(deep=deep)\n- if index:\n- v += self.index.memory_usage(deep=deep)\n- return v\n-\n- def isin(self, values) -> Series:\n- \"\"\"\n- Whether elements in Series are contained in `values`.\n-\n- Return a boolean Series showing whether each element in the Series\n- matches an element in the passed sequence of `values` exactly.\n-\n- Parameters\n- ----------\n- values : set or list-like\n- The sequence of values to test. Passing in a single string will\n- raise a ``TypeError``. Instead, turn a single string into a\n- list of one element.\n-\n- Returns\n- -------\n- Series\n- Series of booleans indicating if each element is in values.\n-\n- Raises\n- ------\n- TypeError\n- * If `values` is a string\n-\n- See Also\n- --------\n- DataFrame.isin : Equivalent method on DataFrame.\n-\n- Examples\n- --------\n- >>> s = pd.Series(['lama', 'cow', 'lama', 'beetle', 'lama',\n- ... 'hippo'], name='animal')\n- >>> s.isin(['cow', 'lama'])\n- 0 True\n- 1 True\n- 2 True\n- 3 False\n- 4 True\n- 5 False\n- Name: animal, dtype: bool\n-\n- To invert the boolean values, use the ``~`` operator:\n-\n- >>> ~s.isin(['cow', 'lama'])\n- 0 False\n- 1 False\n- 2 False\n- 3 True\n- 4 False\n- 5 True\n- Name: animal, dtype: bool\n-\n- Passing a single string as ``s.isin('lama')`` will raise an error. Use\n- a list of one element instead:\n-\n- >>> s.isin(['lama'])\n- 0 True\n- 1 False\n- 2 True\n- 3 False\n- 4 True\n- 5 False\n- Name: animal, dtype: bool\n-\n- Strings and integers are distinct and are therefore not comparable:\n-\n- >>> pd.Series([1]).isin(['1'])\n- 0 False\n- dtype: bool\n- >>> pd.Series([1.1]).isin(['1.1'])\n- 0 False\n- dtype: bool\n- \"\"\"\n- result = algorithms.isin(self._values, values)\n- return self._constructor(result, index=self.index).__finalize__(\n- self, method=\"isin\"\n- )\n-\n- def between(self, left, right, inclusive=\"both\") -> Series:\n- \"\"\"\n- Return boolean Series equivalent to left <= series <= right.\n-\n- This function returns a boolean vector containing `True` wherever the\n- corresponding Series element is between the boundary values `left` and\n- `right`. NA values are treated as `False`.\n-\n- Parameters\n- ----------\n- left : scalar or list-like\n- Left boundary.\n- right : scalar or list-like\n- Right boundary.\n- inclusive : {\"both\", \"neither\", \"left\", \"right\"}\n- Include boundaries. Whether to set each bound as closed or open.\n-\n- .. versionchanged:: 1.3.0\n-\n- Returns\n- -------\n- Series\n- Series representing whether each element is between left and\n- right (inclusive).\n-\n- See Also\n- --------\n- Series.gt : Greater than of series and other.\n- Series.lt : Less than of series and other.\n-\n- Notes\n- -----\n- This function is equivalent to ``(left <= ser) & (ser <= right)``\n-\n- Examples\n- --------\n- >>> s = pd.Series([2, 0, 4, 8, np.nan])\n-\n- Boundary values are included by default:\n-\n- >>> s.between(1, 4)\n- 0 True\n- 1 False\n- 2 True\n- 3 False\n- 4 False\n- dtype: bool\n-\n- With `inclusive` set to ``\"neither\"`` boundary values are excluded:\n-\n- >>> s.between(1, 4, inclusive=\"neither\")\n- 0 True\n- 1 False\n- 2 False\n- 3 False\n- 4 False\n- dtype: bool\n-\n- `left` and `right` can be any scalar value:\n-\n- >>> s = pd.Series(['Alice', 'Bob', 'Carol', 'Eve'])\n- >>> s.between('Anna', 'Daniel')\n- 0 False\n- 1 True\n- 2 True\n- 3 False\n- dtype: bool\n- \"\"\"\n- if inclusive is True or inclusive is False:\n- warnings.warn(\n- \"Boolean inputs to the `inclusive` argument are deprecated in \"\n- \"favour of `both` or `neither`.\",\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n- if inclusive:\n- inclusive = \"both\"\n- else:\n- inclusive = \"neither\"\n- if inclusive == \"both\":\n- lmask = self >= left\n- rmask = self <= right\n- elif inclusive == \"left\":\n- lmask = self >= left\n- rmask = self < right\n- elif inclusive == \"right\":\n- lmask = self > left\n- rmask = self <= right\n- elif inclusive == \"neither\":\n- lmask = self > left\n- rmask = self < right\n- else:\n- raise ValueError(\n- \"Inclusive has to be either string of 'both',\"\n- \"'left', 'right', or 'neither'.\"\n- )\n-\n- return lmask & rmask\n-\n- # ----------------------------------------------------------------------\n- # Convert to types that support pd.NA\n-\n- def _convert_dtypes(\n- self,\n- infer_objects: bool = True,\n- convert_string: bool = True,\n- convert_integer: bool = True,\n- convert_boolean: bool = True,\n- convert_floating: bool = True,\n- ) -> Series:\n- input_series = self\n- if infer_objects:\n- input_series = input_series.infer_objects()\n- if is_object_dtype(input_series):\n- input_series = input_series.copy()\n-\n- if convert_string or convert_integer or convert_boolean or convert_floating:\n- inferred_dtype = convert_dtypes(\n- input_series._values,\n- convert_string,\n- convert_integer,\n- convert_boolean,\n- convert_floating,\n- )\n- result = input_series.astype(inferred_dtype)\n- else:\n- result = input_series.copy()\n- return result\n-\n- # error: Cannot determine type of 'isna'\n- @doc(NDFrame.isna, klass=_shared_doc_kwargs[\"klass\"]) # type: ignore[has-type]\n- def isna(self) -> Series:\n- return NDFrame.isna(self)\n-\n- # error: Cannot determine type of 'isna'\n- @doc(NDFrame.isna, klass=_shared_doc_kwargs[\"klass\"]) # type: ignore[has-type]\n- def isnull(self) -> Series:\n- \"\"\"\n- Series.isnull is an alias for Series.isna.\n- \"\"\"\n- return super().isnull()\n-\n- # error: Cannot determine type of 'notna'\n- @doc(NDFrame.notna, klass=_shared_doc_kwargs[\"klass\"]) # type: ignore[has-type]\n- def notna(self) -> Series:\n- return super().notna()\n-\n- # error: Cannot determine type of 'notna'\n- @doc(NDFrame.notna, klass=_shared_doc_kwargs[\"klass\"]) # type: ignore[has-type]\n- def notnull(self) -> Series:\n- \"\"\"\n- Series.notnull is an alias for Series.notna.\n- \"\"\"\n- return super().notnull()\n-\n- @deprecate_nonkeyword_arguments(version=None, allowed_args=[\"self\"])\n- def dropna(self, axis=0, inplace=False, how=None):\n- \"\"\"\n- Return a new Series with missing values removed.\n-\n- See the :ref:`User Guide <missing_data>` for more on which values are\n- considered missing, and how to work with missing data.\n-\n- Parameters\n- ----------\n- axis : {0 or 'index'}\n- Unused. Parameter needed for compatibility with DataFrame.\n- inplace : bool, default False\n- If True, do operation inplace and return None.\n- how : str, optional\n- Not in use. Kept for compatibility.\n-\n- Returns\n- -------\n- Series or None\n- Series with NA entries dropped from it or None if ``inplace=True``.\n-\n- See Also\n- --------\n- Series.isna: Indicate missing values.\n- Series.notna : Indicate existing (non-missing) values.\n- Series.fillna : Replace missing values.\n- DataFrame.dropna : Drop rows or columns which contain NA values.\n- Index.dropna : Drop missing indices.\n-\n- Examples\n- --------\n- >>> ser = pd.Series([1., 2., np.nan])\n- >>> ser\n- 0 1.0\n- 1 2.0\n- 2 NaN\n- dtype: float64\n-\n- Drop NA values from a Series.\n-\n- >>> ser.dropna()\n- 0 1.0\n- 1 2.0\n- dtype: float64\n-\n- Keep the Series with valid entries in the same variable.\n-\n- >>> ser.dropna(inplace=True)\n- >>> ser\n- 0 1.0\n- 1 2.0\n- dtype: float64\n-\n- Empty strings are not considered NA values. ``None`` is considered an\n- NA value.\n-\n- >>> ser = pd.Series([np.NaN, 2, pd.NaT, '', None, 'I stay'])\n- >>> ser\n- 0 NaN\n- 1 2\n- 2 NaT\n- 3\n- 4 None\n- 5 I stay\n- dtype: object\n- >>> ser.dropna()\n- 1 2\n- 3\n- 5 I stay\n- dtype: object\n- \"\"\"\n- inplace = validate_bool_kwarg(inplace, \"inplace\")\n- # Validate the axis parameter\n- self._get_axis_number(axis or 0)\n-\n- if self._can_hold_na:\n- result = remove_na_arraylike(self)\n- if inplace:\n- self._update_inplace(result)\n- else:\n- return result\n- else:\n- if inplace:\n- # do nothing\n- pass\n- else:\n- return self.copy()\n-\n- # ----------------------------------------------------------------------\n- # Time series-oriented methods\n-\n- # error: Cannot determine type of 'asfreq'\n- @doc(NDFrame.asfreq, **_shared_doc_kwargs) # type: ignore[has-type]\n- def asfreq(\n- self,\n- freq,\n- method=None,\n- how: str | None = None,\n- normalize: bool = False,\n- fill_value=None,\n- ) -> Series:\n- return super().asfreq(\n- freq=freq,\n- method=method,\n- how=how,\n- normalize=normalize,\n- fill_value=fill_value,\n- )\n-\n- # error: Cannot determine type of 'resample'\n- @doc(NDFrame.resample, **_shared_doc_kwargs) # type: ignore[has-type]\n- def resample(\n- self,\n- rule,\n- axis=0,\n- closed: str | None = None,\n- label: str | None = None,\n- convention: str = \"start\",\n- kind: str | None = None,\n- loffset=None,\n- base: int | None = None,\n- on=None,\n- level=None,\n- origin: str | TimestampConvertibleTypes = \"start_day\",\n- offset: TimedeltaConvertibleTypes | None = None,\n- group_keys: bool | lib.NoDefault = no_default,\n- ) -> Resampler:\n- return super().resample(\n- rule=rule,\n- axis=axis,\n- closed=closed,\n- label=label,\n- convention=convention,\n- kind=kind,\n- loffset=loffset,\n- base=base,\n- on=on,\n- level=level,\n- origin=origin,\n- offset=offset,\n- group_keys=group_keys,\n- )\n-\n- def to_timestamp(self, freq=None, how=\"start\", copy=True) -> Series:\n- \"\"\"\n- Cast to DatetimeIndex of Timestamps, at *beginning* of period.\n-\n- Parameters\n- ----------\n- freq : str, default frequency of PeriodIndex\n- Desired frequency.\n- how : {'s', 'e', 'start', 'end'}\n- Convention for converting period to timestamp; start of period\n- vs. end.\n- copy : bool, default True\n- Whether or not to return a copy.\n-\n- Returns\n- -------\n- Series with DatetimeIndex\n- \"\"\"\n- new_values = self._values\n- if copy:\n- new_values = new_values.copy()\n-\n- if not isinstance(self.index, PeriodIndex):\n- raise TypeError(f\"unsupported Type {type(self.index).__name__}\")\n- new_index = self.index.to_timestamp(freq=freq, how=how)\n- return self._constructor(new_values, index=new_index).__finalize__(\n- self, method=\"to_timestamp\"\n- )\n-\n- def to_period(self, freq=None, copy=True) -> Series:\n- \"\"\"\n- Convert Series from DatetimeIndex to PeriodIndex.\n-\n- Parameters\n- ----------\n- freq : str, default None\n- Frequency associated with the PeriodIndex.\n- copy : bool, default True\n- Whether or not to return a copy.\n-\n- Returns\n- -------\n- Series\n- Series with index converted to PeriodIndex.\n- \"\"\"\n- new_values = self._values\n- if copy:\n- new_values = new_values.copy()\n-\n- if not isinstance(self.index, DatetimeIndex):\n- raise TypeError(f\"unsupported Type {type(self.index).__name__}\")\n- new_index = self.index.to_period(freq=freq)\n- return self._constructor(new_values, index=new_index).__finalize__(\n- self, method=\"to_period\"\n- )\n-\n- @deprecate_nonkeyword_arguments(version=None, allowed_args=[\"self\"])\n- def ffill(\n- self: Series,\n- axis: None | Axis = None,\n- inplace: bool = False,\n- limit: None | int = None,\n- downcast=None,\n- ) -> Series | None:\n- return super().ffill(axis, inplace, limit, downcast)\n-\n- @deprecate_nonkeyword_arguments(version=None, allowed_args=[\"self\"])\n- def bfill(\n- self: Series,\n- axis: None | Axis = None,\n- inplace: bool = False,\n- limit: None | int = None,\n- downcast=None,\n- ) -> Series | None:\n- return super().bfill(axis, inplace, limit, downcast)\n-\n- @deprecate_nonkeyword_arguments(\n- version=None, allowed_args=[\"self\", \"lower\", \"upper\"]\n- )\n- def clip(\n- self: Series,\n- lower=None,\n- upper=None,\n- axis: Axis | None = None,\n- inplace: bool = False,\n- *args,\n- **kwargs,\n- ) -> Series | None:\n- return super().clip(lower, upper, axis, inplace, *args, **kwargs)\n-\n- @deprecate_nonkeyword_arguments(version=None, allowed_args=[\"self\", \"method\"])\n- def interpolate(\n- self: Series,\n- method: str = \"linear\",\n- axis: Axis = 0,\n- limit: int | None = None,\n- inplace: bool = False,\n- limit_direction: str | None = None,\n- limit_area: str | None = None,\n- downcast: str | None = None,\n- **kwargs,\n- ) -> Series | None:\n- return super().interpolate(\n- method,\n- axis,\n- limit,\n- inplace,\n- limit_direction,\n- limit_area,\n- downcast,\n- **kwargs,\n- )\n-\n- @deprecate_nonkeyword_arguments(\n- version=None, allowed_args=[\"self\", \"cond\", \"other\"]\n- )\n- def where(\n- self,\n- cond,\n- other=lib.no_default,\n- inplace=False,\n- axis=None,\n- level=None,\n- errors=lib.no_default,\n- try_cast=lib.no_default,\n- ):\n- return super().where(cond, other, inplace, axis, level, errors, try_cast)\n-\n- @deprecate_nonkeyword_arguments(\n- version=None, allowed_args=[\"self\", \"cond\", \"other\"]\n- )\n- def mask(\n- self,\n- cond,\n- other=np.nan,\n- inplace=False,\n- axis=None,\n- level=None,\n- errors=lib.no_default,\n- try_cast=lib.no_default,\n- ):\n- return super().mask(cond, other, inplace, axis, level, errors, try_cast)\n-\n- # ----------------------------------------------------------------------\n- # Add index\n- _AXIS_ORDERS = [\"index\"]\n- _AXIS_LEN = len(_AXIS_ORDERS)\n- _info_axis_number = 0\n- _info_axis_name = \"index\"\n-\n- index = properties.AxisProperty(\n- axis=0, doc=\"The index (axis labels) of the Series.\"\n- )\n-\n- # ----------------------------------------------------------------------\n- # Accessor Methods\n- # ----------------------------------------------------------------------\n- str = CachedAccessor(\"str\", StringMethods)\n- dt = CachedAccessor(\"dt\", CombinedDatetimelikeProperties)\n- cat = CachedAccessor(\"cat\", CategoricalAccessor)\n- plot = CachedAccessor(\"plot\", pandas.plotting.PlotAccessor)\n- sparse = CachedAccessor(\"sparse\", SparseAccessor)\n-\n- # ----------------------------------------------------------------------\n- # Add plotting methods to Series\n- hist = pandas.plotting.hist_series\n-\n- # ----------------------------------------------------------------------\n- # Template-Based Arithmetic/Comparison Methods\n-\n- def _cmp_method(self, other, op):\n- res_name = ops.get_op_result_name(self, other)\n-\n- if isinstance(other, Series) and not self._indexed_same(other):\n- raise ValueError(\"Can only compare identically-labeled Series objects\")\n-\n- lvalues = self._values\n- rvalues = extract_array(other, extract_numpy=True, extract_range=True)\n-\n- with np.errstate(all=\"ignore\"):\n- res_values = ops.comparison_op(lvalues, rvalues, op)\n-\n- return self._construct_result(res_values, name=res_name)\n-\n- def _logical_method(self, other, op):\n- res_name = ops.get_op_result_name(self, other)\n- self, other = ops.align_method_SERIES(self, other, align_asobject=True)\n-\n- lvalues = self._values\n- rvalues = extract_array(other, extract_numpy=True, extract_range=True)\n-\n- res_values = ops.logical_op(lvalues, rvalues, op)\n- return self._construct_result(res_values, name=res_name)\n-\n- def _arith_method(self, other, op):\n- self, other = ops.align_method_SERIES(self, other)\n- return base.IndexOpsMixin._arith_method(self, other, op)\n-\n-\n-Series._add_numeric_operations()\n-\n-# Add arithmetic!\n-ops.add_flex_arithmetic_methods(Series)\n+from pandas._core.series import *\ndiff --git a/pandas/core/shared_docs.py b/pandas/core/shared_docs.py\nindex 3a8a95865d10e..eeeb5cbdd31b5 100644\n--- a/pandas/core/shared_docs.py\n+++ b/pandas/core/shared_docs.py\n@@ -1,888 +1 @@\n-from __future__ import annotations\n-\n-_shared_docs: dict[str, str] = {}\n-\n-_shared_docs[\n- \"aggregate\"\n-] = \"\"\"\n-Aggregate using one or more operations over the specified axis.\n-\n-Parameters\n-----------\n-func : function, str, list or dict\n- Function to use for aggregating the data. If a function, must either\n- work when passed a {klass} or when passed to {klass}.apply.\n-\n- Accepted combinations are:\n-\n- - function\n- - string function name\n- - list of functions and/or function names, e.g. ``[np.sum, 'mean']``\n- - dict of axis labels -> functions, function names or list of such.\n-{axis}\n-*args\n- Positional arguments to pass to `func`.\n-**kwargs\n- Keyword arguments to pass to `func`.\n-\n-Returns\n--------\n-scalar, Series or DataFrame\n-\n- The return can be:\n-\n- * scalar : when Series.agg is called with single function\n- * Series : when DataFrame.agg is called with a single function\n- * DataFrame : when DataFrame.agg is called with several functions\n-\n- Return scalar, Series or DataFrame.\n-{see_also}\n-Notes\n------\n-`agg` is an alias for `aggregate`. Use the alias.\n-\n-Functions that mutate the passed object can produce unexpected\n-behavior or errors and are not supported. See :ref:`gotchas.udf-mutation`\n-for more details.\n-\n-A passed user-defined-function will be passed a Series for evaluation.\n-{examples}\"\"\"\n-\n-_shared_docs[\n- \"compare\"\n-] = \"\"\"\n-Compare to another {klass} and show the differences.\n-\n-.. versionadded:: 1.1.0\n-\n-Parameters\n-----------\n-other : {klass}\n- Object to compare with.\n-\n-align_axis : {{0 or 'index', 1 or 'columns'}}, default 1\n- Determine which axis to align the comparison on.\n-\n- * 0, or 'index' : Resulting differences are stacked vertically\n- with rows drawn alternately from self and other.\n- * 1, or 'columns' : Resulting differences are aligned horizontally\n- with columns drawn alternately from self and other.\n-\n-keep_shape : bool, default False\n- If true, all rows and columns are kept.\n- Otherwise, only the ones with different values are kept.\n-\n-keep_equal : bool, default False\n- If true, the result keeps values that are equal.\n- Otherwise, equal values are shown as NaNs.\n-\"\"\"\n-\n-_shared_docs[\n- \"groupby\"\n-] = \"\"\"\n-Group %(klass)s using a mapper or by a Series of columns.\n-\n-A groupby operation involves some combination of splitting the\n-object, applying a function, and combining the results. This can be\n-used to group large amounts of data and compute operations on these\n-groups.\n-\n-Parameters\n-----------\n-by : mapping, function, label, or list of labels\n- Used to determine the groups for the groupby.\n- If ``by`` is a function, it's called on each value of the object's\n- index. If a dict or Series is passed, the Series or dict VALUES\n- will be used to determine the groups (the Series' values are first\n- aligned; see ``.align()`` method). If a list or ndarray of length\n- equal to the selected axis is passed (see the `groupby user guide\n- <https://pandas.pydata.org/pandas-docs/stable/user_guide/groupby.html#splitting-an-object-into-groups>`_),\n- the values are used as-is to determine the groups. A label or list\n- of labels may be passed to group by the columns in ``self``.\n- Notice that a tuple is interpreted as a (single) key.\n-axis : {0 or 'index', 1 or 'columns'}, default 0\n- Split along rows (0) or columns (1). For `Series` this parameter\n- is unused and defaults to 0.\n-level : int, level name, or sequence of such, default None\n- If the axis is a MultiIndex (hierarchical), group by a particular\n- level or levels.\n-as_index : bool, default True\n- For aggregated output, return object with group labels as the\n- index. Only relevant for DataFrame input. as_index=False is\n- effectively \"SQL-style\" grouped output.\n-sort : bool, default True\n- Sort group keys. Get better performance by turning this off.\n- Note this does not influence the order of observations within each\n- group. Groupby preserves the order of rows within each group.\n-group_keys : bool, optional\n- When calling apply and the ``by`` argument produces a like-indexed\n- (i.e. :ref:`a transform <groupby.transform>`) result, add group keys to\n- index to identify pieces. By default group keys are not included\n- when the result's index (and column) labels match the inputs, and\n- are included otherwise. This argument has no effect if the result produced\n- is not like-indexed with respect to the input.\n-\n- .. versionchanged:: 1.5.0\n-\n- Warns that `group_keys` will no longer be ignored when the\n- result from ``apply`` is a like-indexed Series or DataFrame.\n- Specify ``group_keys`` explicitly to include the group keys or\n- not.\n-squeeze : bool, default False\n- Reduce the dimensionality of the return type if possible,\n- otherwise return a consistent type.\n-\n- .. deprecated:: 1.1.0\n-\n-observed : bool, default False\n- This only applies if any of the groupers are Categoricals.\n- If True: only show observed values for categorical groupers.\n- If False: show all values for categorical groupers.\n-dropna : bool, default True\n- If True, and if group keys contain NA values, NA values together\n- with row/column will be dropped.\n- If False, NA values will also be treated as the key in groups.\n-\n- .. versionadded:: 1.1.0\n-\n-Returns\n--------\n-%(klass)sGroupBy\n- Returns a groupby object that contains information about the groups.\n-\n-See Also\n---------\n-resample : Convenience method for frequency conversion and resampling\n- of time series.\n-\n-Notes\n------\n-See the `user guide\n-<https://pandas.pydata.org/pandas-docs/stable/groupby.html>`__ for more\n-detailed usage and examples, including splitting an object into groups,\n-iterating through groups, selecting a group, aggregation, and more.\n-\"\"\"\n-\n-_shared_docs[\n- \"melt\"\n-] = \"\"\"\n-Unpivot a DataFrame from wide to long format, optionally leaving identifiers set.\n-\n-This function is useful to massage a DataFrame into a format where one\n-or more columns are identifier variables (`id_vars`), while all other\n-columns, considered measured variables (`value_vars`), are \"unpivoted\" to\n-the row axis, leaving just two non-identifier columns, 'variable' and\n-'value'.\n-\n-Parameters\n-----------\n-id_vars : tuple, list, or ndarray, optional\n- Column(s) to use as identifier variables.\n-value_vars : tuple, list, or ndarray, optional\n- Column(s) to unpivot. If not specified, uses all columns that\n- are not set as `id_vars`.\n-var_name : scalar\n- Name to use for the 'variable' column. If None it uses\n- ``frame.columns.name`` or 'variable'.\n-value_name : scalar, default 'value'\n- Name to use for the 'value' column.\n-col_level : int or str, optional\n- If columns are a MultiIndex then use this level to melt.\n-ignore_index : bool, default True\n- If True, original index is ignored. If False, the original index is retained.\n- Index labels will be repeated as necessary.\n-\n- .. versionadded:: 1.1.0\n-\n-Returns\n--------\n-DataFrame\n- Unpivoted DataFrame.\n-\n-See Also\n---------\n-%(other)s : Identical method.\n-pivot_table : Create a spreadsheet-style pivot table as a DataFrame.\n-DataFrame.pivot : Return reshaped DataFrame organized\n- by given index / column values.\n-DataFrame.explode : Explode a DataFrame from list-like\n- columns to long format.\n-\n-Notes\n------\n-Reference :ref:`the user guide <reshaping.melt>` for more examples.\n-\n-Examples\n---------\n->>> df = pd.DataFrame({'A': {0: 'a', 1: 'b', 2: 'c'},\n-... 'B': {0: 1, 1: 3, 2: 5},\n-... 'C': {0: 2, 1: 4, 2: 6}})\n->>> df\n- A B C\n-0 a 1 2\n-1 b 3 4\n-2 c 5 6\n-\n->>> %(caller)sid_vars=['A'], value_vars=['B'])\n- A variable value\n-0 a B 1\n-1 b B 3\n-2 c B 5\n-\n->>> %(caller)sid_vars=['A'], value_vars=['B', 'C'])\n- A variable value\n-0 a B 1\n-1 b B 3\n-2 c B 5\n-3 a C 2\n-4 b C 4\n-5 c C 6\n-\n-The names of 'variable' and 'value' columns can be customized:\n-\n->>> %(caller)sid_vars=['A'], value_vars=['B'],\n-... var_name='myVarname', value_name='myValname')\n- A myVarname myValname\n-0 a B 1\n-1 b B 3\n-2 c B 5\n-\n-Original index values can be kept around:\n-\n->>> %(caller)sid_vars=['A'], value_vars=['B', 'C'], ignore_index=False)\n- A variable value\n-0 a B 1\n-1 b B 3\n-2 c B 5\n-0 a C 2\n-1 b C 4\n-2 c C 6\n-\n-If you have multi-index columns:\n-\n->>> df.columns = [list('ABC'), list('DEF')]\n->>> df\n- A B C\n- D E F\n-0 a 1 2\n-1 b 3 4\n-2 c 5 6\n-\n->>> %(caller)scol_level=0, id_vars=['A'], value_vars=['B'])\n- A variable value\n-0 a B 1\n-1 b B 3\n-2 c B 5\n-\n->>> %(caller)sid_vars=[('A', 'D')], value_vars=[('B', 'E')])\n- (A, D) variable_0 variable_1 value\n-0 a B E 1\n-1 b B E 3\n-2 c B E 5\n-\"\"\"\n-\n-_shared_docs[\n- \"transform\"\n-] = \"\"\"\n-Call ``func`` on self producing a {klass} with the same axis shape as self.\n-\n-Parameters\n-----------\n-func : function, str, list-like or dict-like\n- Function to use for transforming the data. If a function, must either\n- work when passed a {klass} or when passed to {klass}.apply. If func\n- is both list-like and dict-like, dict-like behavior takes precedence.\n-\n- Accepted combinations are:\n-\n- - function\n- - string function name\n- - list-like of functions and/or function names, e.g. ``[np.exp, 'sqrt']``\n- - dict-like of axis labels -> functions, function names or list-like of such.\n-{axis}\n-*args\n- Positional arguments to pass to `func`.\n-**kwargs\n- Keyword arguments to pass to `func`.\n-\n-Returns\n--------\n-{klass}\n- A {klass} that must have the same length as self.\n-\n-Raises\n-------\n-ValueError : If the returned {klass} has a different length than self.\n-\n-See Also\n---------\n-{klass}.agg : Only perform aggregating type operations.\n-{klass}.apply : Invoke function on a {klass}.\n-\n-Notes\n------\n-Functions that mutate the passed object can produce unexpected\n-behavior or errors and are not supported. See :ref:`gotchas.udf-mutation`\n-for more details.\n-\n-Examples\n---------\n->>> df = pd.DataFrame({{'A': range(3), 'B': range(1, 4)}})\n->>> df\n- A B\n-0 0 1\n-1 1 2\n-2 2 3\n->>> df.transform(lambda x: x + 1)\n- A B\n-0 1 2\n-1 2 3\n-2 3 4\n-\n-Even though the resulting {klass} must have the same length as the\n-input {klass}, it is possible to provide several input functions:\n-\n->>> s = pd.Series(range(3))\n->>> s\n-0 0\n-1 1\n-2 2\n-dtype: int64\n->>> s.transform([np.sqrt, np.exp])\n- sqrt exp\n-0 0.000000 1.000000\n-1 1.000000 2.718282\n-2 1.414214 7.389056\n-\n-You can call transform on a GroupBy object:\n-\n->>> df = pd.DataFrame({{\n-... \"Date\": [\n-... \"2015-05-08\", \"2015-05-07\", \"2015-05-06\", \"2015-05-05\",\n-... \"2015-05-08\", \"2015-05-07\", \"2015-05-06\", \"2015-05-05\"],\n-... \"Data\": [5, 8, 6, 1, 50, 100, 60, 120],\n-... }})\n->>> df\n- Date Data\n-0 2015-05-08 5\n-1 2015-05-07 8\n-2 2015-05-06 6\n-3 2015-05-05 1\n-4 2015-05-08 50\n-5 2015-05-07 100\n-6 2015-05-06 60\n-7 2015-05-05 120\n->>> df.groupby('Date')['Data'].transform('sum')\n-0 55\n-1 108\n-2 66\n-3 121\n-4 55\n-5 108\n-6 66\n-7 121\n-Name: Data, dtype: int64\n-\n->>> df = pd.DataFrame({{\n-... \"c\": [1, 1, 1, 2, 2, 2, 2],\n-... \"type\": [\"m\", \"n\", \"o\", \"m\", \"m\", \"n\", \"n\"]\n-... }})\n->>> df\n- c type\n-0 1 m\n-1 1 n\n-2 1 o\n-3 2 m\n-4 2 m\n-5 2 n\n-6 2 n\n->>> df['size'] = df.groupby('c')['type'].transform(len)\n->>> df\n- c type size\n-0 1 m 3\n-1 1 n 3\n-2 1 o 3\n-3 2 m 4\n-4 2 m 4\n-5 2 n 4\n-6 2 n 4\n-\"\"\"\n-\n-_shared_docs[\n- \"storage_options\"\n-] = \"\"\"storage_options : dict, optional\n- Extra options that make sense for a particular storage connection, e.g.\n- host, port, username, password, etc. For HTTP(S) URLs the key-value pairs\n- are forwarded to ``urllib.request.Request`` as header options. For other\n- URLs (e.g. starting with \"s3://\", and \"gcs://\") the key-value pairs are\n- forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more\n- details, and for more examples on storage options refer `here\n- <https://pandas.pydata.org/docs/user_guide/io.html?\n- highlight=storage_options#reading-writing-remote-files>`_.\"\"\"\n-\n-_shared_docs[\n- \"compression_options\"\n-] = \"\"\"compression : str or dict, default 'infer'\n- For on-the-fly compression of the output data. If 'infer' and '%s'\n- path-like, then detect compression from the following extensions: '.gz',\n- '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2'\n- (otherwise no compression).\n- Set to ``None`` for no compression.\n- Can also be a dict with key ``'method'`` set\n- to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'tar'``} and other\n- key-value pairs are forwarded to\n- ``zipfile.ZipFile``, ``gzip.GzipFile``,\n- ``bz2.BZ2File``, ``zstandard.ZstdDecompressor`` or\n- ``tarfile.TarFile``, respectively.\n- As an example, the following could be passed for faster compression and to create\n- a reproducible gzip archive:\n- ``compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}``.\n-\n- .. versionadded:: 1.5.0\n- Added support for `.tar` files.\"\"\"\n-\n-_shared_docs[\n- \"decompression_options\"\n-] = \"\"\"compression : str or dict, default 'infer'\n- For on-the-fly decompression of on-disk data. If 'infer' and '%s' is\n- path-like, then detect compression from the following extensions: '.gz',\n- '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2'\n- (otherwise no compression).\n- If using 'zip' or 'tar', the ZIP file must contain only one data file to be read in.\n- Set to ``None`` for no decompression.\n- Can also be a dict with key ``'method'`` set\n- to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'tar'``} and other\n- key-value pairs are forwarded to\n- ``zipfile.ZipFile``, ``gzip.GzipFile``,\n- ``bz2.BZ2File``, ``zstandard.ZstdDecompressor`` or\n- ``tarfile.TarFile``, respectively.\n- As an example, the following could be passed for Zstandard decompression using a\n- custom compression dictionary:\n- ``compression={'method': 'zstd', 'dict_data': my_compression_dict}``.\n-\n- .. versionadded:: 1.5.0\n- Added support for `.tar` files.\"\"\"\n-\n-_shared_docs[\n- \"replace\"\n-] = \"\"\"\n- Replace values given in `to_replace` with `value`.\n-\n- Values of the {klass} are replaced with other values dynamically.\n- {replace_iloc}\n-\n- Parameters\n- ----------\n- to_replace : str, regex, list, dict, Series, int, float, or None\n- How to find the values that will be replaced.\n-\n- * numeric, str or regex:\n-\n- - numeric: numeric values equal to `to_replace` will be\n- replaced with `value`\n- - str: string exactly matching `to_replace` will be replaced\n- with `value`\n- - regex: regexs matching `to_replace` will be replaced with\n- `value`\n-\n- * list of str, regex, or numeric:\n-\n- - First, if `to_replace` and `value` are both lists, they\n- **must** be the same length.\n- - Second, if ``regex=True`` then all of the strings in **both**\n- lists will be interpreted as regexs otherwise they will match\n- directly. This doesn't matter much for `value` since there\n- are only a few possible substitution regexes you can use.\n- - str, regex and numeric rules apply as above.\n-\n- * dict:\n-\n- - Dicts can be used to specify different replacement values\n- for different existing values. For example,\n- ``{{'a': 'b', 'y': 'z'}}`` replaces the value 'a' with 'b' and\n- 'y' with 'z'. To use a dict in this way, the optional `value`\n- parameter should not be given.\n- - For a DataFrame a dict can specify that different values\n- should be replaced in different columns. For example,\n- ``{{'a': 1, 'b': 'z'}}`` looks for the value 1 in column 'a'\n- and the value 'z' in column 'b' and replaces these values\n- with whatever is specified in `value`. The `value` parameter\n- should not be ``None`` in this case. You can treat this as a\n- special case of passing two lists except that you are\n- specifying the column to search in.\n- - For a DataFrame nested dictionaries, e.g.,\n- ``{{'a': {{'b': np.nan}}}}``, are read as follows: look in column\n- 'a' for the value 'b' and replace it with NaN. The optional `value`\n- parameter should not be specified to use a nested dict in this\n- way. You can nest regular expressions as well. Note that\n- column names (the top-level dictionary keys in a nested\n- dictionary) **cannot** be regular expressions.\n-\n- * None:\n-\n- - This means that the `regex` argument must be a string,\n- compiled regular expression, or list, dict, ndarray or\n- Series of such elements. If `value` is also ``None`` then\n- this **must** be a nested dictionary or Series.\n-\n- See the examples section for examples of each of these.\n- value : scalar, dict, list, str, regex, default None\n- Value to replace any values matching `to_replace` with.\n- For a DataFrame a dict of values can be used to specify which\n- value to use for each column (columns not in the dict will not be\n- filled). Regular expressions, strings and lists or dicts of such\n- objects are also allowed.\n- {inplace}\n- limit : int, default None\n- Maximum size gap to forward or backward fill.\n- regex : bool or same types as `to_replace`, default False\n- Whether to interpret `to_replace` and/or `value` as regular\n- expressions. If this is ``True`` then `to_replace` *must* be a\n- string. Alternatively, this could be a regular expression or a\n- list, dict, or array of regular expressions in which case\n- `to_replace` must be ``None``.\n- method : {{'pad', 'ffill', 'bfill', `None`}}\n- The method to use when for replacement, when `to_replace` is a\n- scalar, list or tuple and `value` is ``None``.\n-\n- .. versionchanged:: 0.23.0\n- Added to DataFrame.\n-\n- Returns\n- -------\n- {klass}\n- Object after replacement.\n-\n- Raises\n- ------\n- AssertionError\n- * If `regex` is not a ``bool`` and `to_replace` is not\n- ``None``.\n-\n- TypeError\n- * If `to_replace` is not a scalar, array-like, ``dict``, or ``None``\n- * If `to_replace` is a ``dict`` and `value` is not a ``list``,\n- ``dict``, ``ndarray``, or ``Series``\n- * If `to_replace` is ``None`` and `regex` is not compilable\n- into a regular expression or is a list, dict, ndarray, or\n- Series.\n- * When replacing multiple ``bool`` or ``datetime64`` objects and\n- the arguments to `to_replace` does not match the type of the\n- value being replaced\n-\n- ValueError\n- * If a ``list`` or an ``ndarray`` is passed to `to_replace` and\n- `value` but they are not the same length.\n-\n- See Also\n- --------\n- {klass}.fillna : Fill NA values.\n- {klass}.where : Replace values based on boolean condition.\n- Series.str.replace : Simple string replacement.\n-\n- Notes\n- -----\n- * Regex substitution is performed under the hood with ``re.sub``. The\n- rules for substitution for ``re.sub`` are the same.\n- * Regular expressions will only substitute on strings, meaning you\n- cannot provide, for example, a regular expression matching floating\n- point numbers and expect the columns in your frame that have a\n- numeric dtype to be matched. However, if those floating point\n- numbers *are* strings, then you can do this.\n- * This method has *a lot* of options. You are encouraged to experiment\n- and play with this method to gain intuition about how it works.\n- * When dict is used as the `to_replace` value, it is like\n- key(s) in the dict are the to_replace part and\n- value(s) in the dict are the value parameter.\n-\n- Examples\n- --------\n-\n- **Scalar `to_replace` and `value`**\n-\n- >>> s = pd.Series([1, 2, 3, 4, 5])\n- >>> s.replace(1, 5)\n- 0 5\n- 1 2\n- 2 3\n- 3 4\n- 4 5\n- dtype: int64\n-\n- >>> df = pd.DataFrame({{'A': [0, 1, 2, 3, 4],\n- ... 'B': [5, 6, 7, 8, 9],\n- ... 'C': ['a', 'b', 'c', 'd', 'e']}})\n- >>> df.replace(0, 5)\n- A B C\n- 0 5 5 a\n- 1 1 6 b\n- 2 2 7 c\n- 3 3 8 d\n- 4 4 9 e\n-\n- **List-like `to_replace`**\n-\n- >>> df.replace([0, 1, 2, 3], 4)\n- A B C\n- 0 4 5 a\n- 1 4 6 b\n- 2 4 7 c\n- 3 4 8 d\n- 4 4 9 e\n-\n- >>> df.replace([0, 1, 2, 3], [4, 3, 2, 1])\n- A B C\n- 0 4 5 a\n- 1 3 6 b\n- 2 2 7 c\n- 3 1 8 d\n- 4 4 9 e\n-\n- >>> s.replace([1, 2], method='bfill')\n- 0 3\n- 1 3\n- 2 3\n- 3 4\n- 4 5\n- dtype: int64\n-\n- **dict-like `to_replace`**\n-\n- >>> df.replace({{0: 10, 1: 100}})\n- A B C\n- 0 10 5 a\n- 1 100 6 b\n- 2 2 7 c\n- 3 3 8 d\n- 4 4 9 e\n-\n- >>> df.replace({{'A': 0, 'B': 5}}, 100)\n- A B C\n- 0 100 100 a\n- 1 1 6 b\n- 2 2 7 c\n- 3 3 8 d\n- 4 4 9 e\n-\n- >>> df.replace({{'A': {{0: 100, 4: 400}}}})\n- A B C\n- 0 100 5 a\n- 1 1 6 b\n- 2 2 7 c\n- 3 3 8 d\n- 4 400 9 e\n-\n- **Regular expression `to_replace`**\n-\n- >>> df = pd.DataFrame({{'A': ['bat', 'foo', 'bait'],\n- ... 'B': ['abc', 'bar', 'xyz']}})\n- >>> df.replace(to_replace=r'^ba.$', value='new', regex=True)\n- A B\n- 0 new abc\n- 1 foo new\n- 2 bait xyz\n-\n- >>> df.replace({{'A': r'^ba.$'}}, {{'A': 'new'}}, regex=True)\n- A B\n- 0 new abc\n- 1 foo bar\n- 2 bait xyz\n-\n- >>> df.replace(regex=r'^ba.$', value='new')\n- A B\n- 0 new abc\n- 1 foo new\n- 2 bait xyz\n-\n- >>> df.replace(regex={{r'^ba.$': 'new', 'foo': 'xyz'}})\n- A B\n- 0 new abc\n- 1 xyz new\n- 2 bait xyz\n-\n- >>> df.replace(regex=[r'^ba.$', 'foo'], value='new')\n- A B\n- 0 new abc\n- 1 new new\n- 2 bait xyz\n-\n- Compare the behavior of ``s.replace({{'a': None}})`` and\n- ``s.replace('a', None)`` to understand the peculiarities\n- of the `to_replace` parameter:\n-\n- >>> s = pd.Series([10, 'a', 'a', 'b', 'a'])\n-\n- When one uses a dict as the `to_replace` value, it is like the\n- value(s) in the dict are equal to the `value` parameter.\n- ``s.replace({{'a': None}})`` is equivalent to\n- ``s.replace(to_replace={{'a': None}}, value=None, method=None)``:\n-\n- >>> s.replace({{'a': None}})\n- 0 10\n- 1 None\n- 2 None\n- 3 b\n- 4 None\n- dtype: object\n-\n- When ``value`` is not explicitly passed and `to_replace` is a scalar, list\n- or tuple, `replace` uses the method parameter (default 'pad') to do the\n- replacement. So this is why the 'a' values are being replaced by 10\n- in rows 1 and 2 and 'b' in row 4 in this case.\n-\n- >>> s.replace('a')\n- 0 10\n- 1 10\n- 2 10\n- 3 b\n- 4 b\n- dtype: object\n-\n- On the other hand, if ``None`` is explicitly passed for ``value``, it will\n- be respected:\n-\n- >>> s.replace('a', None)\n- 0 10\n- 1 None\n- 2 None\n- 3 b\n- 4 None\n- dtype: object\n-\n- .. versionchanged:: 1.4.0\n- Previously the explicit ``None`` was silently ignored.\n-\"\"\"\n-\n-_shared_docs[\n- \"idxmin\"\n-] = \"\"\"\n- Return index of first occurrence of minimum over requested axis.\n-\n- NA/null values are excluded.\n-\n- Parameters\n- ----------\n- axis : {{0 or 'index', 1 or 'columns'}}, default 0\n- The axis to use. 0 or 'index' for row-wise, 1 or 'columns' for column-wise.\n- skipna : bool, default True\n- Exclude NA/null values. If an entire row/column is NA, the result\n- will be NA.\n- numeric_only : bool, default {numeric_only_default}\n- Include only `float`, `int` or `boolean` data.\n-\n- .. versionadded:: 1.5.0\n-\n- Returns\n- -------\n- Series\n- Indexes of minima along the specified axis.\n-\n- Raises\n- ------\n- ValueError\n- * If the row/column is empty\n-\n- See Also\n- --------\n- Series.idxmin : Return index of the minimum element.\n-\n- Notes\n- -----\n- This method is the DataFrame version of ``ndarray.argmin``.\n-\n- Examples\n- --------\n- Consider a dataset containing food consumption in Argentina.\n-\n- >>> df = pd.DataFrame({{'consumption': [10.51, 103.11, 55.48],\n- ... 'co2_emissions': [37.2, 19.66, 1712]}},\n- ... index=['Pork', 'Wheat Products', 'Beef'])\n-\n- >>> df\n- consumption co2_emissions\n- Pork 10.51 37.20\n- Wheat Products 103.11 19.66\n- Beef 55.48 1712.00\n-\n- By default, it returns the index for the minimum value in each column.\n-\n- >>> df.idxmin()\n- consumption Pork\n- co2_emissions Wheat Products\n- dtype: object\n-\n- To return the index for the minimum value in each row, use ``axis=\"columns\"``.\n-\n- >>> df.idxmin(axis=\"columns\")\n- Pork consumption\n- Wheat Products co2_emissions\n- Beef consumption\n- dtype: object\n-\"\"\"\n-\n-_shared_docs[\n- \"idxmax\"\n-] = \"\"\"\n- Return index of first occurrence of maximum over requested axis.\n-\n- NA/null values are excluded.\n-\n- Parameters\n- ----------\n- axis : {{0 or 'index', 1 or 'columns'}}, default 0\n- The axis to use. 0 or 'index' for row-wise, 1 or 'columns' for column-wise.\n- skipna : bool, default True\n- Exclude NA/null values. If an entire row/column is NA, the result\n- will be NA.\n- numeric_only : bool, default {numeric_only_default}\n- Include only `float`, `int` or `boolean` data.\n-\n- .. versionadded:: 1.5.0\n-\n- Returns\n- -------\n- Series\n- Indexes of maxima along the specified axis.\n-\n- Raises\n- ------\n- ValueError\n- * If the row/column is empty\n-\n- See Also\n- --------\n- Series.idxmax : Return index of the maximum element.\n-\n- Notes\n- -----\n- This method is the DataFrame version of ``ndarray.argmax``.\n-\n- Examples\n- --------\n- Consider a dataset containing food consumption in Argentina.\n-\n- >>> df = pd.DataFrame({{'consumption': [10.51, 103.11, 55.48],\n- ... 'co2_emissions': [37.2, 19.66, 1712]}},\n- ... index=['Pork', 'Wheat Products', 'Beef'])\n-\n- >>> df\n- consumption co2_emissions\n- Pork 10.51 37.20\n- Wheat Products 103.11 19.66\n- Beef 55.48 1712.00\n-\n- By default, it returns the index for the maximum value in each column.\n-\n- >>> df.idxmax()\n- consumption Wheat Products\n- co2_emissions Beef\n- dtype: object\n-\n- To return the index for the maximum value in each row, use ``axis=\"columns\"``.\n-\n- >>> df.idxmax(axis=\"columns\")\n- Pork co2_emissions\n- Wheat Products consumption\n- Beef co2_emissions\n- dtype: object\n-\"\"\"\n+from pandas._core.shared_docs import *\ndiff --git a/pandas/core/sorting.py b/pandas/core/sorting.py\nindex 16facfc915e40..c3212351d9f71 100644\n--- a/pandas/core/sorting.py\n+++ b/pandas/core/sorting.py\n@@ -1,732 +1 @@\n-\"\"\" miscellaneous sorting / groupby utilities \"\"\"\n-from __future__ import annotations\n-\n-from collections import defaultdict\n-from typing import (\n- TYPE_CHECKING,\n- Callable,\n- DefaultDict,\n- Hashable,\n- Iterable,\n- Sequence,\n- cast,\n-)\n-import warnings\n-\n-import numpy as np\n-\n-from pandas._libs import (\n- algos,\n- hashtable,\n- lib,\n-)\n-from pandas._libs.hashtable import unique_label_indices\n-from pandas._typing import (\n- IndexKeyFunc,\n- Level,\n- NaPosition,\n- Shape,\n- SortKind,\n- npt,\n-)\n-\n-from pandas.core.dtypes.common import (\n- ensure_int64,\n- ensure_platform_int,\n- is_extension_array_dtype,\n-)\n-from pandas.core.dtypes.generic import (\n- ABCMultiIndex,\n- ABCRangeIndex,\n-)\n-from pandas.core.dtypes.missing import isna\n-\n-from pandas.core.construction import extract_array\n-\n-if TYPE_CHECKING:\n- from pandas import MultiIndex\n- from pandas.core.arrays import ExtensionArray\n- from pandas.core.indexes.base import Index\n-\n-\n-def get_indexer_indexer(\n- target: Index,\n- level: Level | list[Level] | None,\n- ascending: Sequence[bool] | bool,\n- kind: SortKind,\n- na_position: NaPosition,\n- sort_remaining: bool,\n- key: IndexKeyFunc,\n-) -> npt.NDArray[np.intp] | None:\n- \"\"\"\n- Helper method that return the indexer according to input parameters for\n- the sort_index method of DataFrame and Series.\n-\n- Parameters\n- ----------\n- target : Index\n- level : int or level name or list of ints or list of level names\n- ascending : bool or list of bools, default True\n- kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, default 'quicksort'\n- na_position : {'first', 'last'}, default 'last'\n- sort_remaining : bool, default True\n- key : callable, optional\n-\n- Returns\n- -------\n- Optional[ndarray[intp]]\n- The indexer for the new index.\n- \"\"\"\n-\n- target = ensure_key_mapped(target, key, levels=level)\n- target = target._sort_levels_monotonic()\n-\n- if level is not None:\n- _, indexer = target.sortlevel(\n- level, ascending=ascending, sort_remaining=sort_remaining\n- )\n- elif isinstance(target, ABCMultiIndex):\n- indexer = lexsort_indexer(\n- target._get_codes_for_sorting(), orders=ascending, na_position=na_position\n- )\n- else:\n- # Check monotonic-ness before sort an index (GH 11080)\n- if (ascending and target.is_monotonic_increasing) or (\n- not ascending and target.is_monotonic_decreasing\n- ):\n- return None\n-\n- # ascending can only be a Sequence for MultiIndex\n- indexer = nargsort(\n- target,\n- kind=kind,\n- ascending=cast(bool, ascending),\n- na_position=na_position,\n- )\n- return indexer\n-\n-\n-def get_group_index(\n- labels, shape: Shape, sort: bool, xnull: bool\n-) -> npt.NDArray[np.int64]:\n- \"\"\"\n- For the particular label_list, gets the offsets into the hypothetical list\n- representing the totally ordered cartesian product of all possible label\n- combinations, *as long as* this space fits within int64 bounds;\n- otherwise, though group indices identify unique combinations of\n- labels, they cannot be deconstructed.\n- - If `sort`, rank of returned ids preserve lexical ranks of labels.\n- i.e. returned id's can be used to do lexical sort on labels;\n- - If `xnull` nulls (-1 labels) are passed through.\n-\n- Parameters\n- ----------\n- labels : sequence of arrays\n- Integers identifying levels at each location\n- shape : tuple[int, ...]\n- Number of unique levels at each location\n- sort : bool\n- If the ranks of returned ids should match lexical ranks of labels\n- xnull : bool\n- If true nulls are excluded. i.e. -1 values in the labels are\n- passed through.\n-\n- Returns\n- -------\n- An array of type int64 where two elements are equal if their corresponding\n- labels are equal at all location.\n-\n- Notes\n- -----\n- The length of `labels` and `shape` must be identical.\n- \"\"\"\n-\n- def _int64_cut_off(shape) -> int:\n- acc = 1\n- for i, mul in enumerate(shape):\n- acc *= int(mul)\n- if not acc < lib.i8max:\n- return i\n- return len(shape)\n-\n- def maybe_lift(lab, size) -> tuple[np.ndarray, int]:\n- # promote nan values (assigned -1 label in lab array)\n- # so that all output values are non-negative\n- return (lab + 1, size + 1) if (lab == -1).any() else (lab, size)\n-\n- labels = [ensure_int64(x) for x in labels]\n- lshape = list(shape)\n- if not xnull:\n- for i, (lab, size) in enumerate(zip(labels, shape)):\n- lab, size = maybe_lift(lab, size)\n- labels[i] = lab\n- lshape[i] = size\n-\n- labels = list(labels)\n-\n- # Iteratively process all the labels in chunks sized so less\n- # than lib.i8max unique int ids will be required for each chunk\n- while True:\n- # how many levels can be done without overflow:\n- nlev = _int64_cut_off(lshape)\n-\n- # compute flat ids for the first `nlev` levels\n- stride = np.prod(lshape[1:nlev], dtype=\"i8\")\n- out = stride * labels[0].astype(\"i8\", subok=False, copy=False)\n-\n- for i in range(1, nlev):\n- if lshape[i] == 0:\n- stride = np.int64(0)\n- else:\n- stride //= lshape[i]\n- out += labels[i] * stride\n-\n- if xnull: # exclude nulls\n- mask = labels[0] == -1\n- for lab in labels[1:nlev]:\n- mask |= lab == -1\n- out[mask] = -1\n-\n- if nlev == len(lshape): # all levels done!\n- break\n-\n- # compress what has been done so far in order to avoid overflow\n- # to retain lexical ranks, obs_ids should be sorted\n- comp_ids, obs_ids = compress_group_index(out, sort=sort)\n-\n- labels = [comp_ids] + labels[nlev:]\n- lshape = [len(obs_ids)] + lshape[nlev:]\n-\n- return out\n-\n-\n-def get_compressed_ids(\n- labels, sizes: Shape\n-) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.int64]]:\n- \"\"\"\n- Group_index is offsets into cartesian product of all possible labels. This\n- space can be huge, so this function compresses it, by computing offsets\n- (comp_ids) into the list of unique labels (obs_group_ids).\n-\n- Parameters\n- ----------\n- labels : list of label arrays\n- sizes : tuple[int] of size of the levels\n-\n- Returns\n- -------\n- np.ndarray[np.intp]\n- comp_ids\n- np.ndarray[np.int64]\n- obs_group_ids\n- \"\"\"\n- ids = get_group_index(labels, sizes, sort=True, xnull=False)\n- return compress_group_index(ids, sort=True)\n-\n-\n-def is_int64_overflow_possible(shape: Shape) -> bool:\n- the_prod = 1\n- for x in shape:\n- the_prod *= int(x)\n-\n- return the_prod >= lib.i8max\n-\n-\n-def _decons_group_index(\n- comp_labels: npt.NDArray[np.intp], shape: Shape\n-) -> list[npt.NDArray[np.intp]]:\n- # reconstruct labels\n- if is_int64_overflow_possible(shape):\n- # at some point group indices are factorized,\n- # and may not be deconstructed here! wrong path!\n- raise ValueError(\"cannot deconstruct factorized group indices!\")\n-\n- label_list = []\n- factor = 1\n- y = np.array(0)\n- x = comp_labels\n- for i in reversed(range(len(shape))):\n- labels = (x - y) % (factor * shape[i]) // factor\n- np.putmask(labels, comp_labels < 0, -1)\n- label_list.append(labels)\n- y = labels * factor\n- factor *= shape[i]\n- return label_list[::-1]\n-\n-\n-def decons_obs_group_ids(\n- comp_ids: npt.NDArray[np.intp],\n- obs_ids: npt.NDArray[np.intp],\n- shape: Shape,\n- labels: Sequence[npt.NDArray[np.signedinteger]],\n- xnull: bool,\n-) -> list[npt.NDArray[np.intp]]:\n- \"\"\"\n- Reconstruct labels from observed group ids.\n-\n- Parameters\n- ----------\n- comp_ids : np.ndarray[np.intp]\n- obs_ids: np.ndarray[np.intp]\n- shape : tuple[int]\n- labels : Sequence[np.ndarray[np.signedinteger]]\n- xnull : bool\n- If nulls are excluded; i.e. -1 labels are passed through.\n- \"\"\"\n- if not xnull:\n- lift = np.fromiter(((a == -1).any() for a in labels), dtype=np.intp)\n- arr_shape = np.asarray(shape, dtype=np.intp) + lift\n- shape = tuple(arr_shape)\n-\n- if not is_int64_overflow_possible(shape):\n- # obs ids are deconstructable! take the fast route!\n- out = _decons_group_index(obs_ids, shape)\n- return out if xnull or not lift.any() else [x - y for x, y in zip(out, lift)]\n-\n- indexer = unique_label_indices(comp_ids)\n- return [lab[indexer].astype(np.intp, subok=False, copy=True) for lab in labels]\n-\n-\n-def indexer_from_factorized(\n- labels, shape: Shape, compress: bool = True\n-) -> npt.NDArray[np.intp]:\n- ids = get_group_index(labels, shape, sort=True, xnull=False)\n-\n- if not compress:\n- ngroups = (ids.size and ids.max()) + 1\n- else:\n- ids, obs = compress_group_index(ids, sort=True)\n- ngroups = len(obs)\n-\n- return get_group_index_sorter(ids, ngroups)\n-\n-\n-def lexsort_indexer(\n- keys, orders=None, na_position: str = \"last\", key: Callable | None = None\n-) -> npt.NDArray[np.intp]:\n- \"\"\"\n- Performs lexical sorting on a set of keys\n-\n- Parameters\n- ----------\n- keys : sequence of arrays\n- Sequence of ndarrays to be sorted by the indexer\n- orders : bool or list of booleans, optional\n- Determines the sorting order for each element in keys. If a list,\n- it must be the same length as keys. This determines whether the\n- corresponding element in keys should be sorted in ascending\n- (True) or descending (False) order. if bool, applied to all\n- elements as above. if None, defaults to True.\n- na_position : {'first', 'last'}, default 'last'\n- Determines placement of NA elements in the sorted list (\"last\" or \"first\")\n- key : Callable, optional\n- Callable key function applied to every element in keys before sorting\n-\n- .. versionadded:: 1.0.0\n-\n- Returns\n- -------\n- np.ndarray[np.intp]\n- \"\"\"\n- from pandas.core.arrays import Categorical\n-\n- labels = []\n- shape = []\n- if isinstance(orders, bool):\n- orders = [orders] * len(keys)\n- elif orders is None:\n- orders = [True] * len(keys)\n-\n- keys = [ensure_key_mapped(k, key) for k in keys]\n-\n- for k, order in zip(keys, orders):\n- with warnings.catch_warnings():\n- # TODO(2.0): unnecessary once deprecation is enforced\n- # GH#45618 don't issue warning user can't do anything about\n- warnings.filterwarnings(\"ignore\", \".*SparseArray.*\", category=FutureWarning)\n-\n- cat = Categorical(k, ordered=True)\n-\n- if na_position not in [\"last\", \"first\"]:\n- raise ValueError(f\"invalid na_position: {na_position}\")\n-\n- n = len(cat.categories)\n- codes = cat.codes.copy()\n-\n- mask = cat.codes == -1\n- if order: # ascending\n- if na_position == \"last\":\n- codes = np.where(mask, n, codes)\n- elif na_position == \"first\":\n- codes += 1\n- else: # not order means descending\n- if na_position == \"last\":\n- codes = np.where(mask, n, n - codes - 1)\n- elif na_position == \"first\":\n- codes = np.where(mask, 0, n - codes)\n- if mask.any():\n- n += 1\n-\n- shape.append(n)\n- labels.append(codes)\n-\n- return indexer_from_factorized(labels, tuple(shape))\n-\n-\n-def nargsort(\n- items,\n- kind: str = \"quicksort\",\n- ascending: bool = True,\n- na_position: str = \"last\",\n- key: Callable | None = None,\n- mask: npt.NDArray[np.bool_] | None = None,\n-) -> npt.NDArray[np.intp]:\n- \"\"\"\n- Intended to be a drop-in replacement for np.argsort which handles NaNs.\n-\n- Adds ascending, na_position, and key parameters.\n-\n- (GH #6399, #5231, #27237)\n-\n- Parameters\n- ----------\n- kind : str, default 'quicksort'\n- ascending : bool, default True\n- na_position : {'first', 'last'}, default 'last'\n- key : Optional[Callable], default None\n- mask : Optional[np.ndarray[bool]], default None\n- Passed when called by ExtensionArray.argsort.\n-\n- Returns\n- -------\n- np.ndarray[np.intp]\n- \"\"\"\n-\n- if key is not None:\n- items = ensure_key_mapped(items, key)\n- return nargsort(\n- items,\n- kind=kind,\n- ascending=ascending,\n- na_position=na_position,\n- key=None,\n- mask=mask,\n- )\n-\n- if isinstance(items, ABCRangeIndex):\n- return items.argsort(ascending=ascending) # TODO: test coverage with key?\n- elif not isinstance(items, ABCMultiIndex):\n- items = extract_array(items)\n- if mask is None:\n- mask = np.asarray(isna(items)) # TODO: does this exclude MultiIndex too?\n-\n- if is_extension_array_dtype(items):\n- return items.argsort(ascending=ascending, kind=kind, na_position=na_position)\n- else:\n- items = np.asanyarray(items)\n-\n- idx = np.arange(len(items))\n- non_nans = items[~mask]\n- non_nan_idx = idx[~mask]\n-\n- nan_idx = np.nonzero(mask)[0]\n- if not ascending:\n- non_nans = non_nans[::-1]\n- non_nan_idx = non_nan_idx[::-1]\n- indexer = non_nan_idx[non_nans.argsort(kind=kind)]\n- if not ascending:\n- indexer = indexer[::-1]\n- # Finally, place the NaNs at the end or the beginning according to\n- # na_position\n- if na_position == \"last\":\n- indexer = np.concatenate([indexer, nan_idx])\n- elif na_position == \"first\":\n- indexer = np.concatenate([nan_idx, indexer])\n- else:\n- raise ValueError(f\"invalid na_position: {na_position}\")\n- return ensure_platform_int(indexer)\n-\n-\n-def nargminmax(values: ExtensionArray, method: str, axis: int = 0):\n- \"\"\"\n- Implementation of np.argmin/argmax but for ExtensionArray and which\n- handles missing values.\n-\n- Parameters\n- ----------\n- values : ExtensionArray\n- method : {\"argmax\", \"argmin\"}\n- axis : int, default 0\n-\n- Returns\n- -------\n- int\n- \"\"\"\n- assert method in {\"argmax\", \"argmin\"}\n- func = np.argmax if method == \"argmax\" else np.argmin\n-\n- mask = np.asarray(isna(values))\n- arr_values = values._values_for_argsort()\n-\n- if arr_values.ndim > 1:\n- if mask.any():\n- if axis == 1:\n- zipped = zip(arr_values, mask)\n- else:\n- zipped = zip(arr_values.T, mask.T)\n- return np.array([_nanargminmax(v, m, func) for v, m in zipped])\n- return func(arr_values, axis=axis)\n-\n- return _nanargminmax(arr_values, mask, func)\n-\n-\n-def _nanargminmax(values: np.ndarray, mask: npt.NDArray[np.bool_], func) -> int:\n- \"\"\"\n- See nanargminmax.__doc__.\n- \"\"\"\n- idx = np.arange(values.shape[0])\n- non_nans = values[~mask]\n- non_nan_idx = idx[~mask]\n-\n- return non_nan_idx[func(non_nans)]\n-\n-\n-def _ensure_key_mapped_multiindex(\n- index: MultiIndex, key: Callable, level=None\n-) -> MultiIndex:\n- \"\"\"\n- Returns a new MultiIndex in which key has been applied\n- to all levels specified in level (or all levels if level\n- is None). Used for key sorting for MultiIndex.\n-\n- Parameters\n- ----------\n- index : MultiIndex\n- Index to which to apply the key function on the\n- specified levels.\n- key : Callable\n- Function that takes an Index and returns an Index of\n- the same shape. This key is applied to each level\n- separately. The name of the level can be used to\n- distinguish different levels for application.\n- level : list-like, int or str, default None\n- Level or list of levels to apply the key function to.\n- If None, key function is applied to all levels. Other\n- levels are left unchanged.\n-\n- Returns\n- -------\n- labels : MultiIndex\n- Resulting MultiIndex with modified levels.\n- \"\"\"\n-\n- if level is not None:\n- if isinstance(level, (str, int)):\n- sort_levels = [level]\n- else:\n- sort_levels = level\n-\n- sort_levels = [index._get_level_number(lev) for lev in sort_levels]\n- else:\n- sort_levels = list(range(index.nlevels)) # satisfies mypy\n-\n- mapped = [\n- ensure_key_mapped(index._get_level_values(level), key)\n- if level in sort_levels\n- else index._get_level_values(level)\n- for level in range(index.nlevels)\n- ]\n-\n- return type(index).from_arrays(mapped)\n-\n-\n-def ensure_key_mapped(values, key: Callable | None, levels=None):\n- \"\"\"\n- Applies a callable key function to the values function and checks\n- that the resulting value has the same shape. Can be called on Index\n- subclasses, Series, DataFrames, or ndarrays.\n-\n- Parameters\n- ----------\n- values : Series, DataFrame, Index subclass, or ndarray\n- key : Optional[Callable], key to be called on the values array\n- levels : Optional[List], if values is a MultiIndex, list of levels to\n- apply the key to.\n- \"\"\"\n- from pandas.core.indexes.api import Index\n-\n- if not key:\n- return values\n-\n- if isinstance(values, ABCMultiIndex):\n- return _ensure_key_mapped_multiindex(values, key, level=levels)\n-\n- result = key(values.copy())\n- if len(result) != len(values):\n- raise ValueError(\n- \"User-provided `key` function must not change the shape of the array.\"\n- )\n-\n- try:\n- if isinstance(\n- values, Index\n- ): # convert to a new Index subclass, not necessarily the same\n- result = Index(result)\n- else:\n- type_of_values = type(values)\n- result = type_of_values(result) # try to revert to original type otherwise\n- except TypeError:\n- raise TypeError(\n- f\"User-provided `key` function returned an invalid type {type(result)} \\\n- which could not be converted to {type(values)}.\"\n- )\n-\n- return result\n-\n-\n-def get_flattened_list(\n- comp_ids: npt.NDArray[np.intp],\n- ngroups: int,\n- levels: Iterable[Index],\n- labels: Iterable[np.ndarray],\n-) -> list[tuple]:\n- \"\"\"Map compressed group id -> key tuple.\"\"\"\n- comp_ids = comp_ids.astype(np.int64, copy=False)\n- arrays: DefaultDict[int, list[int]] = defaultdict(list)\n- for labs, level in zip(labels, levels):\n- table = hashtable.Int64HashTable(ngroups)\n- table.map_keys_to_values(comp_ids, labs.astype(np.int64, copy=False))\n- for i in range(ngroups):\n- arrays[i].append(level[table.get_item(i)])\n- return [tuple(array) for array in arrays.values()]\n-\n-\n-def get_indexer_dict(\n- label_list: list[np.ndarray], keys: list[Index]\n-) -> dict[Hashable, npt.NDArray[np.intp]]:\n- \"\"\"\n- Returns\n- -------\n- dict:\n- Labels mapped to indexers.\n- \"\"\"\n- shape = tuple(len(x) for x in keys)\n-\n- group_index = get_group_index(label_list, shape, sort=True, xnull=True)\n- if np.all(group_index == -1):\n- # Short-circuit, lib.indices_fast will return the same\n- return {}\n- ngroups = (\n- ((group_index.size and group_index.max()) + 1)\n- if is_int64_overflow_possible(shape)\n- else np.prod(shape, dtype=\"i8\")\n- )\n-\n- sorter = get_group_index_sorter(group_index, ngroups)\n-\n- sorted_labels = [lab.take(sorter) for lab in label_list]\n- group_index = group_index.take(sorter)\n-\n- return lib.indices_fast(sorter, group_index, keys, sorted_labels)\n-\n-\n-# ----------------------------------------------------------------------\n-# sorting levels...cleverly?\n-\n-\n-def get_group_index_sorter(\n- group_index: npt.NDArray[np.intp], ngroups: int | None = None\n-) -> npt.NDArray[np.intp]:\n- \"\"\"\n- algos.groupsort_indexer implements `counting sort` and it is at least\n- O(ngroups), where\n- ngroups = prod(shape)\n- shape = map(len, keys)\n- that is, linear in the number of combinations (cartesian product) of unique\n- values of groupby keys. This can be huge when doing multi-key groupby.\n- np.argsort(kind='mergesort') is O(count x log(count)) where count is the\n- length of the data-frame;\n- Both algorithms are `stable` sort and that is necessary for correctness of\n- groupby operations. e.g. consider:\n- df.groupby(key)[col].transform('first')\n-\n- Parameters\n- ----------\n- group_index : np.ndarray[np.intp]\n- signed integer dtype\n- ngroups : int or None, default None\n-\n- Returns\n- -------\n- np.ndarray[np.intp]\n- \"\"\"\n- if ngroups is None:\n- ngroups = 1 + group_index.max()\n- count = len(group_index)\n- alpha = 0.0 # taking complexities literally; there may be\n- beta = 1.0 # some room for fine-tuning these parameters\n- do_groupsort = count > 0 and ((alpha + beta * ngroups) < (count * np.log(count)))\n- if do_groupsort:\n- sorter, _ = algos.groupsort_indexer(\n- ensure_platform_int(group_index),\n- ngroups,\n- )\n- # sorter _should_ already be intp, but mypy is not yet able to verify\n- else:\n- sorter = group_index.argsort(kind=\"mergesort\")\n- return ensure_platform_int(sorter)\n-\n-\n-def compress_group_index(\n- group_index: npt.NDArray[np.int64], sort: bool = True\n-) -> tuple[npt.NDArray[np.int64], npt.NDArray[np.int64]]:\n- \"\"\"\n- Group_index is offsets into cartesian product of all possible labels. This\n- space can be huge, so this function compresses it, by computing offsets\n- (comp_ids) into the list of unique labels (obs_group_ids).\n- \"\"\"\n- size_hint = len(group_index)\n- table = hashtable.Int64HashTable(size_hint)\n-\n- group_index = ensure_int64(group_index)\n-\n- # note, group labels come out ascending (ie, 1,2,3 etc)\n- comp_ids, obs_group_ids = table.get_labels_groupby(group_index)\n-\n- if sort and len(obs_group_ids) > 0:\n- obs_group_ids, comp_ids = _reorder_by_uniques(obs_group_ids, comp_ids)\n-\n- return ensure_int64(comp_ids), ensure_int64(obs_group_ids)\n-\n-\n-def _reorder_by_uniques(\n- uniques: npt.NDArray[np.int64], labels: npt.NDArray[np.intp]\n-) -> tuple[npt.NDArray[np.int64], npt.NDArray[np.intp]]:\n- \"\"\"\n- Parameters\n- ----------\n- uniques : np.ndarray[np.int64]\n- labels : np.ndarray[np.intp]\n-\n- Returns\n- -------\n- np.ndarray[np.int64]\n- np.ndarray[np.intp]\n- \"\"\"\n- # sorter is index where elements ought to go\n- sorter = uniques.argsort()\n-\n- # reverse_indexer is where elements came from\n- reverse_indexer = np.empty(len(sorter), dtype=np.intp)\n- reverse_indexer.put(sorter, np.arange(len(sorter)))\n-\n- mask = labels < 0\n-\n- # move labels to right locations (ie, unsort ascending labels)\n- labels = reverse_indexer.take(labels)\n- np.putmask(labels, mask, -1)\n-\n- # sort observed ids\n- uniques = uniques.take(sorter)\n-\n- return uniques, labels\n+from pandas._core.sorting import *\ndiff --git a/pandas/core/sparse/__init__.py b/pandas/core/sparse/__init__.py\nindex e69de29bb2d1d..6b8572b9c7c9f 100644\n--- a/pandas/core/sparse/__init__.py\n+++ b/pandas/core/sparse/__init__.py\n@@ -0,0 +1 @@\n+from pandas._core.sparse.__init__ import *\ndiff --git a/pandas/core/sparse/api.py b/pandas/core/sparse/api.py\nindex 2a324ebf77d9d..a004f86a90e2a 100644\n--- a/pandas/core/sparse/api.py\n+++ b/pandas/core/sparse/api.py\n@@ -1,6 +1 @@\n-from pandas.core.arrays.sparse import (\n- SparseArray,\n- SparseDtype,\n-)\n-\n-__all__ = [\"SparseArray\", \"SparseDtype\"]\n+from pandas._core.sparse.api import *\ndiff --git a/pandas/core/strings/__init__.py b/pandas/core/strings/__init__.py\nindex 28aba7c9ce0b3..b32e6d4978cb2 100644\n--- a/pandas/core/strings/__init__.py\n+++ b/pandas/core/strings/__init__.py\n@@ -1,33 +1 @@\n-\"\"\"\n-Implementation of pandas.Series.str and its interface.\n-\n-* strings.accessor.StringMethods : Accessor for Series.str\n-* strings.base.BaseStringArrayMethods: Mixin ABC for EAs to implement str methods\n-\n-Most methods on the StringMethods accessor follow the pattern:\n-\n- 1. extract the array from the series (or index)\n- 2. Call that array's implementation of the string method\n- 3. Wrap the result (in a Series, index, or DataFrame)\n-\n-Pandas extension arrays implementing string methods should inherit from\n-pandas.core.strings.base.BaseStringArrayMethods. This is an ABC defining\n-the various string methods. To avoid namespace clashes and pollution,\n-these are prefixed with `_str_`. So ``Series.str.upper()`` calls\n-``Series.array._str_upper()``. The interface isn't currently public\n-to other string extension arrays.\n-\"\"\"\n-# Pandas current implementation is in ObjectStringArrayMixin. This is designed\n-# to work on object-dtype ndarrays.\n-#\n-# BaseStringArrayMethods\n-# - ObjectStringArrayMixin\n-# - StringArray\n-# - PandasArray\n-# - Categorical\n-# - ArrowStringArray\n-\n-from pandas.core.strings.accessor import StringMethods\n-from pandas.core.strings.base import BaseStringArrayMethods\n-\n-__all__ = [\"StringMethods\", \"BaseStringArrayMethods\"]\n+from pandas._core.strings.__init__ import *\ndiff --git a/pandas/core/strings/accessor.py b/pandas/core/strings/accessor.py\nindex ae92926195273..68d456cb80659 100644\n--- a/pandas/core/strings/accessor.py\n+++ b/pandas/core/strings/accessor.py\n@@ -1,3332 +1 @@\n-from __future__ import annotations\n-\n-import codecs\n-from functools import wraps\n-import re\n-from typing import (\n- TYPE_CHECKING,\n- Callable,\n- Hashable,\n- cast,\n-)\n-import warnings\n-\n-import numpy as np\n-\n-import pandas._libs.lib as lib\n-from pandas._typing import (\n- DtypeObj,\n- F,\n-)\n-from pandas.util._decorators import (\n- Appender,\n- deprecate_nonkeyword_arguments,\n-)\n-from pandas.util._exceptions import find_stack_level\n-\n-from pandas.core.dtypes.common import (\n- ensure_object,\n- is_bool_dtype,\n- is_categorical_dtype,\n- is_integer,\n- is_list_like,\n- is_object_dtype,\n- is_re,\n-)\n-from pandas.core.dtypes.generic import (\n- ABCDataFrame,\n- ABCIndex,\n- ABCMultiIndex,\n- ABCSeries,\n-)\n-from pandas.core.dtypes.missing import isna\n-\n-from pandas.core.base import NoNewAttributesMixin\n-from pandas.core.construction import extract_array\n-\n-if TYPE_CHECKING:\n- from pandas import (\n- DataFrame,\n- Index,\n- Series,\n- )\n-\n-_shared_docs: dict[str, str] = {}\n-_cpython_optimized_encoders = (\n- \"utf-8\",\n- \"utf8\",\n- \"latin-1\",\n- \"latin1\",\n- \"iso-8859-1\",\n- \"mbcs\",\n- \"ascii\",\n-)\n-_cpython_optimized_decoders = _cpython_optimized_encoders + (\"utf-16\", \"utf-32\")\n-\n-\n-def forbid_nonstring_types(\n- forbidden: list[str] | None, name: str | None = None\n-) -> Callable[[F], F]:\n- \"\"\"\n- Decorator to forbid specific types for a method of StringMethods.\n-\n- For calling `.str.{method}` on a Series or Index, it is necessary to first\n- initialize the :class:`StringMethods` object, and then call the method.\n- However, different methods allow different input types, and so this can not\n- be checked during :meth:`StringMethods.__init__`, but must be done on a\n- per-method basis. This decorator exists to facilitate this process, and\n- make it explicit which (inferred) types are disallowed by the method.\n-\n- :meth:`StringMethods.__init__` allows the *union* of types its different\n- methods allow (after skipping NaNs; see :meth:`StringMethods._validate`),\n- namely: ['string', 'empty', 'bytes', 'mixed', 'mixed-integer'].\n-\n- The default string types ['string', 'empty'] are allowed for all methods.\n- For the additional types ['bytes', 'mixed', 'mixed-integer'], each method\n- then needs to forbid the types it is not intended for.\n-\n- Parameters\n- ----------\n- forbidden : list-of-str or None\n- List of forbidden non-string types, may be one or more of\n- `['bytes', 'mixed', 'mixed-integer']`.\n- name : str, default None\n- Name of the method to use in the error message. By default, this is\n- None, in which case the name from the method being wrapped will be\n- copied. However, for working with further wrappers (like _pat_wrapper\n- and _noarg_wrapper), it is necessary to specify the name.\n-\n- Returns\n- -------\n- func : wrapper\n- The method to which the decorator is applied, with an added check that\n- enforces the inferred type to not be in the list of forbidden types.\n-\n- Raises\n- ------\n- TypeError\n- If the inferred type of the underlying data is in `forbidden`.\n- \"\"\"\n- # deal with None\n- forbidden = [] if forbidden is None else forbidden\n-\n- allowed_types = {\"string\", \"empty\", \"bytes\", \"mixed\", \"mixed-integer\"} - set(\n- forbidden\n- )\n-\n- def _forbid_nonstring_types(func: F) -> F:\n- func_name = func.__name__ if name is None else name\n-\n- @wraps(func)\n- def wrapper(self, *args, **kwargs):\n- if self._inferred_dtype not in allowed_types:\n- msg = (\n- f\"Cannot use .str.{func_name} with values of \"\n- f\"inferred dtype '{self._inferred_dtype}'.\"\n- )\n- raise TypeError(msg)\n- return func(self, *args, **kwargs)\n-\n- wrapper.__name__ = func_name\n- return cast(F, wrapper)\n-\n- return _forbid_nonstring_types\n-\n-\n-def _map_and_wrap(name, docstring):\n- @forbid_nonstring_types([\"bytes\"], name=name)\n- def wrapper(self):\n- result = getattr(self._data.array, f\"_str_{name}\")()\n- return self._wrap_result(result)\n-\n- wrapper.__doc__ = docstring\n- return wrapper\n-\n-\n-class StringMethods(NoNewAttributesMixin):\n- \"\"\"\n- Vectorized string functions for Series and Index.\n-\n- NAs stay NA unless handled otherwise by a particular method.\n- Patterned after Python's string methods, with some inspiration from\n- R's stringr package.\n-\n- Examples\n- --------\n- >>> s = pd.Series([\"A_Str_Series\"])\n- >>> s\n- 0 A_Str_Series\n- dtype: object\n-\n- >>> s.str.split(\"_\")\n- 0 [A, Str, Series]\n- dtype: object\n-\n- >>> s.str.replace(\"_\", \"\")\n- 0 AStrSeries\n- dtype: object\n- \"\"\"\n-\n- # Note: see the docstring in pandas.core.strings.__init__\n- # for an explanation of the implementation.\n- # TODO: Dispatch all the methods\n- # Currently the following are not dispatched to the array\n- # * cat\n- # * extractall\n-\n- def __init__(self, data) -> None:\n- from pandas.core.arrays.string_ import StringDtype\n-\n- self._inferred_dtype = self._validate(data)\n- self._is_categorical = is_categorical_dtype(data.dtype)\n- self._is_string = isinstance(data.dtype, StringDtype)\n- self._data = data\n-\n- self._index = self._name = None\n- if isinstance(data, ABCSeries):\n- self._index = data.index\n- self._name = data.name\n-\n- # ._values.categories works for both Series/Index\n- self._parent = data._values.categories if self._is_categorical else data\n- # save orig to blow up categoricals to the right type\n- self._orig = data\n- self._freeze()\n-\n- @staticmethod\n- def _validate(data):\n- \"\"\"\n- Auxiliary function for StringMethods, infers and checks dtype of data.\n-\n- This is a \"first line of defence\" at the creation of the StringMethods-\n- object, and just checks that the dtype is in the\n- *union* of the allowed types over all string methods below; this\n- restriction is then refined on a per-method basis using the decorator\n- @forbid_nonstring_types (more info in the corresponding docstring).\n-\n- This really should exclude all series/index with any non-string values,\n- but that isn't practical for performance reasons until we have a str\n- dtype (GH 9343 / 13877)\n-\n- Parameters\n- ----------\n- data : The content of the Series\n-\n- Returns\n- -------\n- dtype : inferred dtype of data\n- \"\"\"\n- if isinstance(data, ABCMultiIndex):\n- raise AttributeError(\n- \"Can only use .str accessor with Index, not MultiIndex\"\n- )\n-\n- # see _libs/lib.pyx for list of inferred types\n- allowed_types = [\"string\", \"empty\", \"bytes\", \"mixed\", \"mixed-integer\"]\n-\n- data = extract_array(data)\n-\n- values = getattr(data, \"categories\", data) # categorical / normal\n-\n- inferred_dtype = lib.infer_dtype(values, skipna=True)\n-\n- if inferred_dtype not in allowed_types:\n- raise AttributeError(\"Can only use .str accessor with string values!\")\n- return inferred_dtype\n-\n- def __getitem__(self, key):\n- result = self._data.array._str_getitem(key)\n- return self._wrap_result(result)\n-\n- def __iter__(self):\n- warnings.warn(\n- \"Columnar iteration over characters will be deprecated in future releases.\",\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n- i = 0\n- g = self.get(i)\n- while g.notna().any():\n- yield g\n- i += 1\n- g = self.get(i)\n-\n- def _wrap_result(\n- self,\n- result,\n- name=None,\n- expand: bool | None = None,\n- fill_value=np.nan,\n- returns_string=True,\n- returns_bool: bool = False,\n- ):\n- from pandas import (\n- Index,\n- MultiIndex,\n- )\n-\n- if not hasattr(result, \"ndim\") or not hasattr(result, \"dtype\"):\n- if isinstance(result, ABCDataFrame):\n- result = result.__finalize__(self._orig, name=\"str\")\n- return result\n- assert result.ndim < 3\n-\n- # We can be wrapping a string / object / categorical result, in which\n- # case we'll want to return the same dtype as the input.\n- # Or we can be wrapping a numeric output, in which case we don't want\n- # to return a StringArray.\n- # Ideally the array method returns the right array type.\n- if expand is None:\n- # infer from ndim if expand is not specified\n- expand = result.ndim != 1\n-\n- elif (\n- expand is True\n- and is_object_dtype(result)\n- and not isinstance(self._orig, ABCIndex)\n- ):\n- # required when expand=True is explicitly specified\n- # not needed when inferred\n-\n- def cons_row(x):\n- if is_list_like(x):\n- return x\n- else:\n- return [x]\n-\n- result = [cons_row(x) for x in result]\n- if result and not self._is_string:\n- # propagate nan values to match longest sequence (GH 18450)\n- max_len = max(len(x) for x in result)\n- result = [\n- x * max_len if len(x) == 0 or x[0] is np.nan else x for x in result\n- ]\n-\n- if not isinstance(expand, bool):\n- raise ValueError(\"expand must be True or False\")\n-\n- if expand is False:\n- # if expand is False, result should have the same name\n- # as the original otherwise specified\n- if name is None:\n- name = getattr(result, \"name\", None)\n- if name is None:\n- # do not use logical or, _orig may be a DataFrame\n- # which has \"name\" column\n- name = self._orig.name\n-\n- # Wait until we are sure result is a Series or Index before\n- # checking attributes (GH 12180)\n- if isinstance(self._orig, ABCIndex):\n- # if result is a boolean np.array, return the np.array\n- # instead of wrapping it into a boolean Index (GH 8875)\n- if is_bool_dtype(result):\n- return result\n-\n- if expand:\n- result = list(result)\n- out = MultiIndex.from_tuples(result, names=name)\n- if out.nlevels == 1:\n- # We had all tuples of length-one, which are\n- # better represented as a regular Index.\n- out = out.get_level_values(0)\n- return out\n- else:\n- return Index._with_infer(result, name=name)\n- else:\n- index = self._orig.index\n- # This is a mess.\n- dtype: DtypeObj | str | None\n- vdtype = getattr(result, \"dtype\", None)\n- if self._is_string:\n- if is_bool_dtype(vdtype):\n- dtype = result.dtype\n- elif returns_string:\n- dtype = self._orig.dtype\n- else:\n- dtype = vdtype\n- else:\n- dtype = vdtype\n-\n- if expand:\n- cons = self._orig._constructor_expanddim\n- result = cons(result, columns=name, index=index, dtype=dtype)\n- else:\n- # Must be a Series\n- cons = self._orig._constructor\n- result = cons(result, name=name, index=index, dtype=dtype)\n- result = result.__finalize__(self._orig, method=\"str\")\n- if name is not None and result.ndim == 1:\n- # __finalize__ might copy over the original name, but we may\n- # want the new name (e.g. str.extract).\n- result.name = name\n- return result\n-\n- def _get_series_list(self, others):\n- \"\"\"\n- Auxiliary function for :meth:`str.cat`. Turn potentially mixed input\n- into a list of Series (elements without an index must match the length\n- of the calling Series/Index).\n-\n- Parameters\n- ----------\n- others : Series, DataFrame, np.ndarray, list-like or list-like of\n- Objects that are either Series, Index or np.ndarray (1-dim).\n-\n- Returns\n- -------\n- list of Series\n- Others transformed into list of Series.\n- \"\"\"\n- from pandas import (\n- DataFrame,\n- Series,\n- )\n-\n- # self._orig is either Series or Index\n- idx = self._orig if isinstance(self._orig, ABCIndex) else self._orig.index\n-\n- # Generally speaking, all objects without an index inherit the index\n- # `idx` of the calling Series/Index - i.e. must have matching length.\n- # Objects with an index (i.e. Series/Index/DataFrame) keep their own.\n- if isinstance(others, ABCSeries):\n- return [others]\n- elif isinstance(others, ABCIndex):\n- return [Series(others._values, index=idx, dtype=others.dtype)]\n- elif isinstance(others, ABCDataFrame):\n- return [others[x] for x in others]\n- elif isinstance(others, np.ndarray) and others.ndim == 2:\n- others = DataFrame(others, index=idx)\n- return [others[x] for x in others]\n- elif is_list_like(others, allow_sets=False):\n- others = list(others) # ensure iterators do not get read twice etc\n-\n- # in case of list-like `others`, all elements must be\n- # either Series/Index/np.ndarray (1-dim)...\n- if all(\n- isinstance(x, (ABCSeries, ABCIndex))\n- or (isinstance(x, np.ndarray) and x.ndim == 1)\n- for x in others\n- ):\n- los: list[Series] = []\n- while others: # iterate through list and append each element\n- los = los + self._get_series_list(others.pop(0))\n- return los\n- # ... or just strings\n- elif all(not is_list_like(x) for x in others):\n- return [Series(others, index=idx)]\n- raise TypeError(\n- \"others must be Series, Index, DataFrame, np.ndarray \"\n- \"or list-like (either containing only strings or \"\n- \"containing only objects of type Series/Index/\"\n- \"np.ndarray[1-dim])\"\n- )\n-\n- @forbid_nonstring_types([\"bytes\", \"mixed\", \"mixed-integer\"])\n- def cat(\n- self, others=None, sep=None, na_rep=None, join=\"left\"\n- ) -> str | Series | Index:\n- \"\"\"\n- Concatenate strings in the Series/Index with given separator.\n-\n- If `others` is specified, this function concatenates the Series/Index\n- and elements of `others` element-wise.\n- If `others` is not passed, then all values in the Series/Index are\n- concatenated into a single string with a given `sep`.\n-\n- Parameters\n- ----------\n- others : Series, Index, DataFrame, np.ndarray or list-like\n- Series, Index, DataFrame, np.ndarray (one- or two-dimensional) and\n- other list-likes of strings must have the same length as the\n- calling Series/Index, with the exception of indexed objects (i.e.\n- Series/Index/DataFrame) if `join` is not None.\n-\n- If others is a list-like that contains a combination of Series,\n- Index or np.ndarray (1-dim), then all elements will be unpacked and\n- must satisfy the above criteria individually.\n-\n- If others is None, the method returns the concatenation of all\n- strings in the calling Series/Index.\n- sep : str, default ''\n- The separator between the different elements/columns. By default\n- the empty string `''` is used.\n- na_rep : str or None, default None\n- Representation that is inserted for all missing values:\n-\n- - If `na_rep` is None, and `others` is None, missing values in the\n- Series/Index are omitted from the result.\n- - If `na_rep` is None, and `others` is not None, a row containing a\n- missing value in any of the columns (before concatenation) will\n- have a missing value in the result.\n- join : {'left', 'right', 'outer', 'inner'}, default 'left'\n- Determines the join-style between the calling Series/Index and any\n- Series/Index/DataFrame in `others` (objects without an index need\n- to match the length of the calling Series/Index). To disable\n- alignment, use `.values` on any Series/Index/DataFrame in `others`.\n-\n- .. versionadded:: 0.23.0\n- .. versionchanged:: 1.0.0\n- Changed default of `join` from None to `'left'`.\n-\n- Returns\n- -------\n- str, Series or Index\n- If `others` is None, `str` is returned, otherwise a `Series/Index`\n- (same type as caller) of objects is returned.\n-\n- See Also\n- --------\n- split : Split each string in the Series/Index.\n- join : Join lists contained as elements in the Series/Index.\n-\n- Examples\n- --------\n- When not passing `others`, all values are concatenated into a single\n- string:\n-\n- >>> s = pd.Series(['a', 'b', np.nan, 'd'])\n- >>> s.str.cat(sep=' ')\n- 'a b d'\n-\n- By default, NA values in the Series are ignored. Using `na_rep`, they\n- can be given a representation:\n-\n- >>> s.str.cat(sep=' ', na_rep='?')\n- 'a b ? d'\n-\n- If `others` is specified, corresponding values are concatenated with\n- the separator. Result will be a Series of strings.\n-\n- >>> s.str.cat(['A', 'B', 'C', 'D'], sep=',')\n- 0 a,A\n- 1 b,B\n- 2 NaN\n- 3 d,D\n- dtype: object\n-\n- Missing values will remain missing in the result, but can again be\n- represented using `na_rep`\n-\n- >>> s.str.cat(['A', 'B', 'C', 'D'], sep=',', na_rep='-')\n- 0 a,A\n- 1 b,B\n- 2 -,C\n- 3 d,D\n- dtype: object\n-\n- If `sep` is not specified, the values are concatenated without\n- separation.\n-\n- >>> s.str.cat(['A', 'B', 'C', 'D'], na_rep='-')\n- 0 aA\n- 1 bB\n- 2 -C\n- 3 dD\n- dtype: object\n-\n- Series with different indexes can be aligned before concatenation. The\n- `join`-keyword works as in other methods.\n-\n- >>> t = pd.Series(['d', 'a', 'e', 'c'], index=[3, 0, 4, 2])\n- >>> s.str.cat(t, join='left', na_rep='-')\n- 0 aa\n- 1 b-\n- 2 -c\n- 3 dd\n- dtype: object\n- >>>\n- >>> s.str.cat(t, join='outer', na_rep='-')\n- 0 aa\n- 1 b-\n- 2 -c\n- 3 dd\n- 4 -e\n- dtype: object\n- >>>\n- >>> s.str.cat(t, join='inner', na_rep='-')\n- 0 aa\n- 2 -c\n- 3 dd\n- dtype: object\n- >>>\n- >>> s.str.cat(t, join='right', na_rep='-')\n- 3 dd\n- 0 aa\n- 4 -e\n- 2 -c\n- dtype: object\n-\n- For more examples, see :ref:`here <text.concatenate>`.\n- \"\"\"\n- # TODO: dispatch\n- from pandas import (\n- Index,\n- Series,\n- concat,\n- )\n-\n- if isinstance(others, str):\n- raise ValueError(\"Did you mean to supply a `sep` keyword?\")\n- if sep is None:\n- sep = \"\"\n-\n- if isinstance(self._orig, ABCIndex):\n- data = Series(self._orig, index=self._orig, dtype=self._orig.dtype)\n- else: # Series\n- data = self._orig\n-\n- # concatenate Series/Index with itself if no \"others\"\n- if others is None:\n- # error: Incompatible types in assignment (expression has type\n- # \"ndarray\", variable has type \"Series\")\n- data = ensure_object(data) # type: ignore[assignment]\n- na_mask = isna(data)\n- if na_rep is None and na_mask.any():\n- return sep.join(data[~na_mask])\n- elif na_rep is not None and na_mask.any():\n- return sep.join(np.where(na_mask, na_rep, data))\n- else:\n- return sep.join(data)\n-\n- try:\n- # turn anything in \"others\" into lists of Series\n- others = self._get_series_list(others)\n- except ValueError as err: # do not catch TypeError raised by _get_series_list\n- raise ValueError(\n- \"If `others` contains arrays or lists (or other \"\n- \"list-likes without an index), these must all be \"\n- \"of the same length as the calling Series/Index.\"\n- ) from err\n-\n- # align if required\n- if any(not data.index.equals(x.index) for x in others):\n- # Need to add keys for uniqueness in case of duplicate columns\n- others = concat(\n- others,\n- axis=1,\n- join=(join if join == \"inner\" else \"outer\"),\n- keys=range(len(others)),\n- sort=False,\n- copy=False,\n- )\n- data, others = data.align(others, join=join)\n- others = [others[x] for x in others] # again list of Series\n-\n- all_cols = [ensure_object(x) for x in [data] + others]\n- na_masks = np.array([isna(x) for x in all_cols])\n- union_mask = np.logical_or.reduce(na_masks, axis=0)\n-\n- if na_rep is None and union_mask.any():\n- # no na_rep means NaNs for all rows where any column has a NaN\n- # only necessary if there are actually any NaNs\n- result = np.empty(len(data), dtype=object)\n- np.putmask(result, union_mask, np.nan)\n-\n- not_masked = ~union_mask\n- result[not_masked] = cat_safe([x[not_masked] for x in all_cols], sep)\n- elif na_rep is not None and union_mask.any():\n- # fill NaNs with na_rep in case there are actually any NaNs\n- all_cols = [\n- np.where(nm, na_rep, col) for nm, col in zip(na_masks, all_cols)\n- ]\n- result = cat_safe(all_cols, sep)\n- else:\n- # no NaNs - can just concatenate\n- result = cat_safe(all_cols, sep)\n-\n- out: Index | Series\n- if isinstance(self._orig, ABCIndex):\n- # add dtype for case that result is all-NA\n-\n- out = Index(result, dtype=object, name=self._orig.name)\n- else: # Series\n- if is_categorical_dtype(self._orig.dtype):\n- # We need to infer the new categories.\n- dtype = None\n- else:\n- dtype = self._orig.dtype\n- res_ser = Series(\n- result, dtype=dtype, index=data.index, name=self._orig.name\n- )\n- out = res_ser.__finalize__(self._orig, method=\"str_cat\")\n- return out\n-\n- _shared_docs[\n- \"str_split\"\n- ] = r\"\"\"\n- Split strings around given separator/delimiter.\n-\n- Splits the string in the Series/Index from the %(side)s,\n- at the specified delimiter string.\n-\n- Parameters\n- ----------\n- pat : str%(pat_regex)s, optional\n- %(pat_description)s.\n- If not specified, split on whitespace.\n- n : int, default -1 (all)\n- Limit number of splits in output.\n- ``None``, 0 and -1 will be interpreted as return all splits.\n- expand : bool, default False\n- Expand the split strings into separate columns.\n-\n- - If ``True``, return DataFrame/MultiIndex expanding dimensionality.\n- - If ``False``, return Series/Index, containing lists of strings.\n- %(regex_argument)s\n- Returns\n- -------\n- Series, Index, DataFrame or MultiIndex\n- Type matches caller unless ``expand=True`` (see Notes).\n- %(raises_split)s\n- See Also\n- --------\n- Series.str.split : Split strings around given separator/delimiter.\n- Series.str.rsplit : Splits string around given separator/delimiter,\n- starting from the right.\n- Series.str.join : Join lists contained as elements in the Series/Index\n- with passed delimiter.\n- str.split : Standard library version for split.\n- str.rsplit : Standard library version for rsplit.\n-\n- Notes\n- -----\n- The handling of the `n` keyword depends on the number of found splits:\n-\n- - If found splits > `n`, make first `n` splits only\n- - If found splits <= `n`, make all splits\n- - If for a certain row the number of found splits < `n`,\n- append `None` for padding up to `n` if ``expand=True``\n-\n- If using ``expand=True``, Series and Index callers return DataFrame and\n- MultiIndex objects, respectively.\n- %(regex_pat_note)s\n- Examples\n- --------\n- >>> s = pd.Series(\n- ... [\n- ... \"this is a regular sentence\",\n- ... \"https://docs.python.org/3/tutorial/index.html\",\n- ... np.nan\n- ... ]\n- ... )\n- >>> s\n- 0 this is a regular sentence\n- 1 https://docs.python.org/3/tutorial/index.html\n- 2 NaN\n- dtype: object\n-\n- In the default setting, the string is split by whitespace.\n-\n- >>> s.str.split()\n- 0 [this, is, a, regular, sentence]\n- 1 [https://docs.python.org/3/tutorial/index.html]\n- 2 NaN\n- dtype: object\n-\n- Without the `n` parameter, the outputs of `rsplit` and `split`\n- are identical.\n-\n- >>> s.str.rsplit()\n- 0 [this, is, a, regular, sentence]\n- 1 [https://docs.python.org/3/tutorial/index.html]\n- 2 NaN\n- dtype: object\n-\n- The `n` parameter can be used to limit the number of splits on the\n- delimiter. The outputs of `split` and `rsplit` are different.\n-\n- >>> s.str.split(n=2)\n- 0 [this, is, a regular sentence]\n- 1 [https://docs.python.org/3/tutorial/index.html]\n- 2 NaN\n- dtype: object\n-\n- >>> s.str.rsplit(n=2)\n- 0 [this is a, regular, sentence]\n- 1 [https://docs.python.org/3/tutorial/index.html]\n- 2 NaN\n- dtype: object\n-\n- The `pat` parameter can be used to split by other characters.\n-\n- >>> s.str.split(pat=\"/\")\n- 0 [this is a regular sentence]\n- 1 [https:, , docs.python.org, 3, tutorial, index...\n- 2 NaN\n- dtype: object\n-\n- When using ``expand=True``, the split elements will expand out into\n- separate columns. If NaN is present, it is propagated throughout\n- the columns during the split.\n-\n- >>> s.str.split(expand=True)\n- 0 1 2 3 4\n- 0 this is a regular sentence\n- 1 https://docs.python.org/3/tutorial/index.html None None None None\n- 2 NaN NaN NaN NaN NaN\n-\n- For slightly more complex use cases like splitting the html document name\n- from a url, a combination of parameter settings can be used.\n-\n- >>> s.str.rsplit(\"/\", n=1, expand=True)\n- 0 1\n- 0 this is a regular sentence None\n- 1 https://docs.python.org/3/tutorial index.html\n- 2 NaN NaN\n- %(regex_examples)s\"\"\"\n-\n- @Appender(\n- _shared_docs[\"str_split\"]\n- % {\n- \"side\": \"beginning\",\n- \"pat_regex\": \" or compiled regex\",\n- \"pat_description\": \"String or regular expression to split on\",\n- \"regex_argument\": \"\"\"\n- regex : bool, default None\n- Determines if the passed-in pattern is a regular expression:\n-\n- - If ``True``, assumes the passed-in pattern is a regular expression\n- - If ``False``, treats the pattern as a literal string.\n- - If ``None`` and `pat` length is 1, treats `pat` as a literal string.\n- - If ``None`` and `pat` length is not 1, treats `pat` as a regular expression.\n- - Cannot be set to False if `pat` is a compiled regex\n-\n- .. versionadded:: 1.4.0\n- \"\"\",\n- \"raises_split\": \"\"\"\n- Raises\n- ------\n- ValueError\n- * if `regex` is False and `pat` is a compiled regex\n- \"\"\",\n- \"regex_pat_note\": \"\"\"\n- Use of `regex =False` with a `pat` as a compiled regex will raise an error.\n- \"\"\",\n- \"method\": \"split\",\n- \"regex_examples\": r\"\"\"\n- Remember to escape special characters when explicitly using regular expressions.\n-\n- >>> s = pd.Series([\"foo and bar plus baz\"])\n- >>> s.str.split(r\"and|plus\", expand=True)\n- 0 1 2\n- 0 foo bar baz\n-\n- Regular expressions can be used to handle urls or file names.\n- When `pat` is a string and ``regex=None`` (the default), the given `pat` is compiled\n- as a regex only if ``len(pat) != 1``.\n-\n- >>> s = pd.Series(['foojpgbar.jpg'])\n- >>> s.str.split(r\".\", expand=True)\n- 0 1\n- 0 foojpgbar jpg\n-\n- >>> s.str.split(r\"\\.jpg\", expand=True)\n- 0 1\n- 0 foojpgbar\n-\n- When ``regex=True``, `pat` is interpreted as a regex\n-\n- >>> s.str.split(r\"\\.jpg\", regex=True, expand=True)\n- 0 1\n- 0 foojpgbar\n-\n- A compiled regex can be passed as `pat`\n-\n- >>> import re\n- >>> s.str.split(re.compile(r\"\\.jpg\"), expand=True)\n- 0 1\n- 0 foojpgbar\n-\n- When ``regex=False``, `pat` is interpreted as the string itself\n-\n- >>> s.str.split(r\"\\.jpg\", regex=False, expand=True)\n- 0\n- 0 foojpgbar.jpg\n- \"\"\",\n- }\n- )\n- @deprecate_nonkeyword_arguments(version=None, allowed_args=[\"self\", \"pat\"])\n- @forbid_nonstring_types([\"bytes\"])\n- def split(\n- self,\n- pat: str | re.Pattern | None = None,\n- n=-1,\n- expand=False,\n- *,\n- regex: bool | None = None,\n- ):\n- if regex is False and is_re(pat):\n- raise ValueError(\n- \"Cannot use a compiled regex as replacement pattern with regex=False\"\n- )\n- if is_re(pat):\n- regex = True\n- result = self._data.array._str_split(pat, n, expand, regex)\n- return self._wrap_result(result, returns_string=expand, expand=expand)\n-\n- @Appender(\n- _shared_docs[\"str_split\"]\n- % {\n- \"side\": \"end\",\n- \"pat_regex\": \"\",\n- \"pat_description\": \"String to split on\",\n- \"regex_argument\": \"\",\n- \"raises_split\": \"\",\n- \"regex_pat_note\": \"\",\n- \"method\": \"rsplit\",\n- \"regex_examples\": \"\",\n- }\n- )\n- @deprecate_nonkeyword_arguments(version=None, allowed_args=[\"self\", \"pat\"])\n- @forbid_nonstring_types([\"bytes\"])\n- def rsplit(self, pat=None, n=-1, expand=False):\n- result = self._data.array._str_rsplit(pat, n=n)\n- return self._wrap_result(result, expand=expand, returns_string=expand)\n-\n- _shared_docs[\n- \"str_partition\"\n- ] = \"\"\"\n- Split the string at the %(side)s occurrence of `sep`.\n-\n- This method splits the string at the %(side)s occurrence of `sep`,\n- and returns 3 elements containing the part before the separator,\n- the separator itself, and the part after the separator.\n- If the separator is not found, return %(return)s.\n-\n- Parameters\n- ----------\n- sep : str, default whitespace\n- String to split on.\n- expand : bool, default True\n- If True, return DataFrame/MultiIndex expanding dimensionality.\n- If False, return Series/Index.\n-\n- Returns\n- -------\n- DataFrame/MultiIndex or Series/Index of objects\n-\n- See Also\n- --------\n- %(also)s\n- Series.str.split : Split strings around given separators.\n- str.partition : Standard library version.\n-\n- Examples\n- --------\n-\n- >>> s = pd.Series(['Linda van der Berg', 'George Pitt-Rivers'])\n- >>> s\n- 0 Linda van der Berg\n- 1 George Pitt-Rivers\n- dtype: object\n-\n- >>> s.str.partition()\n- 0 1 2\n- 0 Linda van der Berg\n- 1 George Pitt-Rivers\n-\n- To partition by the last space instead of the first one:\n-\n- >>> s.str.rpartition()\n- 0 1 2\n- 0 Linda van der Berg\n- 1 George Pitt-Rivers\n-\n- To partition by something different than a space:\n-\n- >>> s.str.partition('-')\n- 0 1 2\n- 0 Linda van der Berg\n- 1 George Pitt - Rivers\n-\n- To return a Series containing tuples instead of a DataFrame:\n-\n- >>> s.str.partition('-', expand=False)\n- 0 (Linda van der Berg, , )\n- 1 (George Pitt, -, Rivers)\n- dtype: object\n-\n- Also available on indices:\n-\n- >>> idx = pd.Index(['X 123', 'Y 999'])\n- >>> idx\n- Index(['X 123', 'Y 999'], dtype='object')\n-\n- Which will create a MultiIndex:\n-\n- >>> idx.str.partition()\n- MultiIndex([('X', ' ', '123'),\n- ('Y', ' ', '999')],\n- )\n-\n- Or an index with tuples with ``expand=False``:\n-\n- >>> idx.str.partition(expand=False)\n- Index([('X', ' ', '123'), ('Y', ' ', '999')], dtype='object')\n- \"\"\"\n-\n- @Appender(\n- _shared_docs[\"str_partition\"]\n- % {\n- \"side\": \"first\",\n- \"return\": \"3 elements containing the string itself, followed by two \"\n- \"empty strings\",\n- \"also\": \"rpartition : Split the string at the last occurrence of `sep`.\",\n- }\n- )\n- @forbid_nonstring_types([\"bytes\"])\n- def partition(self, sep=\" \", expand=True):\n- result = self._data.array._str_partition(sep, expand)\n- return self._wrap_result(result, expand=expand, returns_string=expand)\n-\n- @Appender(\n- _shared_docs[\"str_partition\"]\n- % {\n- \"side\": \"last\",\n- \"return\": \"3 elements containing two empty strings, followed by the \"\n- \"string itself\",\n- \"also\": \"partition : Split the string at the first occurrence of `sep`.\",\n- }\n- )\n- @forbid_nonstring_types([\"bytes\"])\n- def rpartition(self, sep=\" \", expand=True):\n- result = self._data.array._str_rpartition(sep, expand)\n- return self._wrap_result(result, expand=expand, returns_string=expand)\n-\n- def get(self, i):\n- \"\"\"\n- Extract element from each component at specified position.\n-\n- Extract element from lists, tuples, or strings in each element in the\n- Series/Index.\n-\n- Parameters\n- ----------\n- i : int\n- Position of element to extract.\n-\n- Returns\n- -------\n- Series or Index\n-\n- Examples\n- --------\n- >>> s = pd.Series([\"String\",\n- ... (1, 2, 3),\n- ... [\"a\", \"b\", \"c\"],\n- ... 123,\n- ... -456,\n- ... {1: \"Hello\", \"2\": \"World\"}])\n- >>> s\n- 0 String\n- 1 (1, 2, 3)\n- 2 [a, b, c]\n- 3 123\n- 4 -456\n- 5 {1: 'Hello', '2': 'World'}\n- dtype: object\n-\n- >>> s.str.get(1)\n- 0 t\n- 1 2\n- 2 b\n- 3 NaN\n- 4 NaN\n- 5 Hello\n- dtype: object\n-\n- >>> s.str.get(-1)\n- 0 g\n- 1 3\n- 2 c\n- 3 NaN\n- 4 NaN\n- 5 None\n- dtype: object\n- \"\"\"\n- result = self._data.array._str_get(i)\n- return self._wrap_result(result)\n-\n- @forbid_nonstring_types([\"bytes\"])\n- def join(self, sep):\n- \"\"\"\n- Join lists contained as elements in the Series/Index with passed delimiter.\n-\n- If the elements of a Series are lists themselves, join the content of these\n- lists using the delimiter passed to the function.\n- This function is an equivalent to :meth:`str.join`.\n-\n- Parameters\n- ----------\n- sep : str\n- Delimiter to use between list entries.\n-\n- Returns\n- -------\n- Series/Index: object\n- The list entries concatenated by intervening occurrences of the\n- delimiter.\n-\n- Raises\n- ------\n- AttributeError\n- If the supplied Series contains neither strings nor lists.\n-\n- See Also\n- --------\n- str.join : Standard library version of this method.\n- Series.str.split : Split strings around given separator/delimiter.\n-\n- Notes\n- -----\n- If any of the list items is not a string object, the result of the join\n- will be `NaN`.\n-\n- Examples\n- --------\n- Example with a list that contains non-string elements.\n-\n- >>> s = pd.Series([['lion', 'elephant', 'zebra'],\n- ... [1.1, 2.2, 3.3],\n- ... ['cat', np.nan, 'dog'],\n- ... ['cow', 4.5, 'goat'],\n- ... ['duck', ['swan', 'fish'], 'guppy']])\n- >>> s\n- 0 [lion, elephant, zebra]\n- 1 [1.1, 2.2, 3.3]\n- 2 [cat, nan, dog]\n- 3 [cow, 4.5, goat]\n- 4 [duck, [swan, fish], guppy]\n- dtype: object\n-\n- Join all lists using a '-'. The lists containing object(s) of types other\n- than str will produce a NaN.\n-\n- >>> s.str.join('-')\n- 0 lion-elephant-zebra\n- 1 NaN\n- 2 NaN\n- 3 NaN\n- 4 NaN\n- dtype: object\n- \"\"\"\n- result = self._data.array._str_join(sep)\n- return self._wrap_result(result)\n-\n- @forbid_nonstring_types([\"bytes\"])\n- def contains(self, pat, case=True, flags=0, na=None, regex=True):\n- r\"\"\"\n- Test if pattern or regex is contained within a string of a Series or Index.\n-\n- Return boolean Series or Index based on whether a given pattern or regex is\n- contained within a string of a Series or Index.\n-\n- Parameters\n- ----------\n- pat : str\n- Character sequence or regular expression.\n- case : bool, default True\n- If True, case sensitive.\n- flags : int, default 0 (no flags)\n- Flags to pass through to the re module, e.g. re.IGNORECASE.\n- na : scalar, optional\n- Fill value for missing values. The default depends on dtype of the\n- array. For object-dtype, ``numpy.nan`` is used. For ``StringDtype``,\n- ``pandas.NA`` is used.\n- regex : bool, default True\n- If True, assumes the pat is a regular expression.\n-\n- If False, treats the pat as a literal string.\n-\n- Returns\n- -------\n- Series or Index of boolean values\n- A Series or Index of boolean values indicating whether the\n- given pattern is contained within the string of each element\n- of the Series or Index.\n-\n- See Also\n- --------\n- match : Analogous, but stricter, relying on re.match instead of re.search.\n- Series.str.startswith : Test if the start of each string element matches a\n- pattern.\n- Series.str.endswith : Same as startswith, but tests the end of string.\n-\n- Examples\n- --------\n- Returning a Series of booleans using only a literal pattern.\n-\n- >>> s1 = pd.Series(['Mouse', 'dog', 'house and parrot', '23', np.NaN])\n- >>> s1.str.contains('og', regex=False)\n- 0 False\n- 1 True\n- 2 False\n- 3 False\n- 4 NaN\n- dtype: object\n-\n- Returning an Index of booleans using only a literal pattern.\n-\n- >>> ind = pd.Index(['Mouse', 'dog', 'house and parrot', '23.0', np.NaN])\n- >>> ind.str.contains('23', regex=False)\n- Index([False, False, False, True, nan], dtype='object')\n-\n- Specifying case sensitivity using `case`.\n-\n- >>> s1.str.contains('oG', case=True, regex=True)\n- 0 False\n- 1 False\n- 2 False\n- 3 False\n- 4 NaN\n- dtype: object\n-\n- Specifying `na` to be `False` instead of `NaN` replaces NaN values\n- with `False`. If Series or Index does not contain NaN values\n- the resultant dtype will be `bool`, otherwise, an `object` dtype.\n-\n- >>> s1.str.contains('og', na=False, regex=True)\n- 0 False\n- 1 True\n- 2 False\n- 3 False\n- 4 False\n- dtype: bool\n-\n- Returning 'house' or 'dog' when either expression occurs in a string.\n-\n- >>> s1.str.contains('house|dog', regex=True)\n- 0 False\n- 1 True\n- 2 True\n- 3 False\n- 4 NaN\n- dtype: object\n-\n- Ignoring case sensitivity using `flags` with regex.\n-\n- >>> import re\n- >>> s1.str.contains('PARROT', flags=re.IGNORECASE, regex=True)\n- 0 False\n- 1 False\n- 2 True\n- 3 False\n- 4 NaN\n- dtype: object\n-\n- Returning any digit using regular expression.\n-\n- >>> s1.str.contains('\\\\d', regex=True)\n- 0 False\n- 1 False\n- 2 False\n- 3 True\n- 4 NaN\n- dtype: object\n-\n- Ensure `pat` is a not a literal pattern when `regex` is set to True.\n- Note in the following example one might expect only `s2[1]` and `s2[3]` to\n- return `True`. However, '.0' as a regex matches any character\n- followed by a 0.\n-\n- >>> s2 = pd.Series(['40', '40.0', '41', '41.0', '35'])\n- >>> s2.str.contains('.0', regex=True)\n- 0 True\n- 1 True\n- 2 False\n- 3 True\n- 4 False\n- dtype: bool\n- \"\"\"\n- if regex and re.compile(pat).groups:\n- warnings.warn(\n- \"This pattern is interpreted as a regular expression, and has \"\n- \"match groups. To actually get the groups, use str.extract.\",\n- UserWarning,\n- stacklevel=find_stack_level(),\n- )\n-\n- result = self._data.array._str_contains(pat, case, flags, na, regex)\n- return self._wrap_result(result, fill_value=na, returns_string=False)\n-\n- @forbid_nonstring_types([\"bytes\"])\n- def match(self, pat, case=True, flags=0, na=None):\n- \"\"\"\n- Determine if each string starts with a match of a regular expression.\n-\n- Parameters\n- ----------\n- pat : str\n- Character sequence or regular expression.\n- case : bool, default True\n- If True, case sensitive.\n- flags : int, default 0 (no flags)\n- Regex module flags, e.g. re.IGNORECASE.\n- na : scalar, optional\n- Fill value for missing values. The default depends on dtype of the\n- array. For object-dtype, ``numpy.nan`` is used. For ``StringDtype``,\n- ``pandas.NA`` is used.\n-\n- Returns\n- -------\n- Series/Index/array of boolean values\n-\n- See Also\n- --------\n- fullmatch : Stricter matching that requires the entire string to match.\n- contains : Analogous, but less strict, relying on re.search instead of\n- re.match.\n- extract : Extract matched groups.\n- \"\"\"\n- result = self._data.array._str_match(pat, case=case, flags=flags, na=na)\n- return self._wrap_result(result, fill_value=na, returns_string=False)\n-\n- @forbid_nonstring_types([\"bytes\"])\n- def fullmatch(self, pat, case=True, flags=0, na=None):\n- \"\"\"\n- Determine if each string entirely matches a regular expression.\n-\n- .. versionadded:: 1.1.0\n-\n- Parameters\n- ----------\n- pat : str\n- Character sequence or regular expression.\n- case : bool, default True\n- If True, case sensitive.\n- flags : int, default 0 (no flags)\n- Regex module flags, e.g. re.IGNORECASE.\n- na : scalar, optional\n- Fill value for missing values. The default depends on dtype of the\n- array. For object-dtype, ``numpy.nan`` is used. For ``StringDtype``,\n- ``pandas.NA`` is used.\n-\n- Returns\n- -------\n- Series/Index/array of boolean values\n-\n- See Also\n- --------\n- match : Similar, but also returns `True` when only a *prefix* of the string\n- matches the regular expression.\n- extract : Extract matched groups.\n- \"\"\"\n- result = self._data.array._str_fullmatch(pat, case=case, flags=flags, na=na)\n- return self._wrap_result(result, fill_value=na, returns_string=False)\n-\n- @forbid_nonstring_types([\"bytes\"])\n- def replace(\n- self,\n- pat: str | re.Pattern,\n- repl: str | Callable,\n- n: int = -1,\n- case: bool | None = None,\n- flags: int = 0,\n- regex: bool | None = None,\n- ):\n- r\"\"\"\n- Replace each occurrence of pattern/regex in the Series/Index.\n-\n- Equivalent to :meth:`str.replace` or :func:`re.sub`, depending on\n- the regex value.\n-\n- Parameters\n- ----------\n- pat : str or compiled regex\n- String can be a character sequence or regular expression.\n- repl : str or callable\n- Replacement string or a callable. The callable is passed the regex\n- match object and must return a replacement string to be used.\n- See :func:`re.sub`.\n- n : int, default -1 (all)\n- Number of replacements to make from start.\n- case : bool, default None\n- Determines if replace is case sensitive:\n-\n- - If True, case sensitive (the default if `pat` is a string)\n- - Set to False for case insensitive\n- - Cannot be set if `pat` is a compiled regex.\n-\n- flags : int, default 0 (no flags)\n- Regex module flags, e.g. re.IGNORECASE. Cannot be set if `pat` is a compiled\n- regex.\n- regex : bool, default True\n- Determines if the passed-in pattern is a regular expression:\n-\n- - If True, assumes the passed-in pattern is a regular expression.\n- - If False, treats the pattern as a literal string\n- - Cannot be set to False if `pat` is a compiled regex or `repl` is\n- a callable.\n-\n- .. versionadded:: 0.23.0\n-\n- Returns\n- -------\n- Series or Index of object\n- A copy of the object with all matching occurrences of `pat` replaced by\n- `repl`.\n-\n- Raises\n- ------\n- ValueError\n- * if `regex` is False and `repl` is a callable or `pat` is a compiled\n- regex\n- * if `pat` is a compiled regex and `case` or `flags` is set\n-\n- Notes\n- -----\n- When `pat` is a compiled regex, all flags should be included in the\n- compiled regex. Use of `case`, `flags`, or `regex=False` with a compiled\n- regex will raise an error.\n-\n- Examples\n- --------\n- When `pat` is a string and `regex` is True (the default), the given `pat`\n- is compiled as a regex. When `repl` is a string, it replaces matching\n- regex patterns as with :meth:`re.sub`. NaN value(s) in the Series are\n- left as is:\n-\n- >>> pd.Series(['foo', 'fuz', np.nan]).str.replace('f.', 'ba', regex=True)\n- 0 bao\n- 1 baz\n- 2 NaN\n- dtype: object\n-\n- When `pat` is a string and `regex` is False, every `pat` is replaced with\n- `repl` as with :meth:`str.replace`:\n-\n- >>> pd.Series(['f.o', 'fuz', np.nan]).str.replace('f.', 'ba', regex=False)\n- 0 bao\n- 1 fuz\n- 2 NaN\n- dtype: object\n-\n- When `repl` is a callable, it is called on every `pat` using\n- :func:`re.sub`. The callable should expect one positional argument\n- (a regex object) and return a string.\n-\n- To get the idea:\n-\n- >>> pd.Series(['foo', 'fuz', np.nan]).str.replace('f', repr, regex=True)\n- 0 <re.Match object; span=(0, 1), match='f'>oo\n- 1 <re.Match object; span=(0, 1), match='f'>uz\n- 2 NaN\n- dtype: object\n-\n- Reverse every lowercase alphabetic word:\n-\n- >>> repl = lambda m: m.group(0)[::-1]\n- >>> ser = pd.Series(['foo 123', 'bar baz', np.nan])\n- >>> ser.str.replace(r'[a-z]+', repl, regex=True)\n- 0 oof 123\n- 1 rab zab\n- 2 NaN\n- dtype: object\n-\n- Using regex groups (extract second group and swap case):\n-\n- >>> pat = r\"(?P<one>\\w+) (?P<two>\\w+) (?P<three>\\w+)\"\n- >>> repl = lambda m: m.group('two').swapcase()\n- >>> ser = pd.Series(['One Two Three', 'Foo Bar Baz'])\n- >>> ser.str.replace(pat, repl, regex=True)\n- 0 tWO\n- 1 bAR\n- dtype: object\n-\n- Using a compiled regex with flags\n-\n- >>> import re\n- >>> regex_pat = re.compile(r'FUZ', flags=re.IGNORECASE)\n- >>> pd.Series(['foo', 'fuz', np.nan]).str.replace(regex_pat, 'bar', regex=True)\n- 0 foo\n- 1 bar\n- 2 NaN\n- dtype: object\n- \"\"\"\n- if regex is None:\n- if isinstance(pat, str) and any(c in pat for c in \".+*|^$?[](){}\\\\\"):\n- # warn only in cases where regex behavior would differ from literal\n- msg = (\n- \"The default value of regex will change from True to False \"\n- \"in a future version.\"\n- )\n- if len(pat) == 1:\n- msg += (\n- \" In addition, single character regular expressions will \"\n- \"*not* be treated as literal strings when regex=True.\"\n- )\n- warnings.warn(msg, FutureWarning, stacklevel=find_stack_level())\n-\n- # Check whether repl is valid (GH 13438, GH 15055)\n- if not (isinstance(repl, str) or callable(repl)):\n- raise TypeError(\"repl must be a string or callable\")\n-\n- is_compiled_re = is_re(pat)\n- if regex or regex is None:\n- if is_compiled_re and (case is not None or flags != 0):\n- raise ValueError(\n- \"case and flags cannot be set when pat is a compiled regex\"\n- )\n-\n- elif is_compiled_re:\n- raise ValueError(\n- \"Cannot use a compiled regex as replacement pattern with regex=False\"\n- )\n- elif callable(repl):\n- raise ValueError(\"Cannot use a callable replacement when regex=False\")\n-\n- # The current behavior is to treat single character patterns as literal strings,\n- # even when ``regex`` is set to ``True``.\n- if isinstance(pat, str) and len(pat) == 1:\n- regex = False\n-\n- if regex is None:\n- regex = True\n-\n- if case is None:\n- case = True\n-\n- result = self._data.array._str_replace(\n- pat, repl, n=n, case=case, flags=flags, regex=regex\n- )\n- return self._wrap_result(result)\n-\n- @forbid_nonstring_types([\"bytes\"])\n- def repeat(self, repeats):\n- \"\"\"\n- Duplicate each string in the Series or Index.\n-\n- Parameters\n- ----------\n- repeats : int or sequence of int\n- Same value for all (int) or different value per (sequence).\n-\n- Returns\n- -------\n- Series or Index of object\n- Series or Index of repeated string objects specified by\n- input parameter repeats.\n-\n- Examples\n- --------\n- >>> s = pd.Series(['a', 'b', 'c'])\n- >>> s\n- 0 a\n- 1 b\n- 2 c\n- dtype: object\n-\n- Single int repeats string in Series\n-\n- >>> s.str.repeat(repeats=2)\n- 0 aa\n- 1 bb\n- 2 cc\n- dtype: object\n-\n- Sequence of int repeats corresponding string in Series\n-\n- >>> s.str.repeat(repeats=[1, 2, 3])\n- 0 a\n- 1 bb\n- 2 ccc\n- dtype: object\n- \"\"\"\n- result = self._data.array._str_repeat(repeats)\n- return self._wrap_result(result)\n-\n- @forbid_nonstring_types([\"bytes\"])\n- def pad(self, width, side=\"left\", fillchar=\" \"):\n- \"\"\"\n- Pad strings in the Series/Index up to width.\n-\n- Parameters\n- ----------\n- width : int\n- Minimum width of resulting string; additional characters will be filled\n- with character defined in `fillchar`.\n- side : {'left', 'right', 'both'}, default 'left'\n- Side from which to fill resulting string.\n- fillchar : str, default ' '\n- Additional character for filling, default is whitespace.\n-\n- Returns\n- -------\n- Series or Index of object\n- Returns Series or Index with minimum number of char in object.\n-\n- See Also\n- --------\n- Series.str.rjust : Fills the left side of strings with an arbitrary\n- character. Equivalent to ``Series.str.pad(side='left')``.\n- Series.str.ljust : Fills the right side of strings with an arbitrary\n- character. Equivalent to ``Series.str.pad(side='right')``.\n- Series.str.center : Fills both sides of strings with an arbitrary\n- character. Equivalent to ``Series.str.pad(side='both')``.\n- Series.str.zfill : Pad strings in the Series/Index by prepending '0'\n- character. Equivalent to ``Series.str.pad(side='left', fillchar='0')``.\n-\n- Examples\n- --------\n- >>> s = pd.Series([\"caribou\", \"tiger\"])\n- >>> s\n- 0 caribou\n- 1 tiger\n- dtype: object\n-\n- >>> s.str.pad(width=10)\n- 0 caribou\n- 1 tiger\n- dtype: object\n-\n- >>> s.str.pad(width=10, side='right', fillchar='-')\n- 0 caribou---\n- 1 tiger-----\n- dtype: object\n-\n- >>> s.str.pad(width=10, side='both', fillchar='-')\n- 0 -caribou--\n- 1 --tiger---\n- dtype: object\n- \"\"\"\n- if not isinstance(fillchar, str):\n- msg = f\"fillchar must be a character, not {type(fillchar).__name__}\"\n- raise TypeError(msg)\n-\n- if len(fillchar) != 1:\n- raise TypeError(\"fillchar must be a character, not str\")\n-\n- if not is_integer(width):\n- msg = f\"width must be of integer type, not {type(width).__name__}\"\n- raise TypeError(msg)\n-\n- result = self._data.array._str_pad(width, side=side, fillchar=fillchar)\n- return self._wrap_result(result)\n-\n- _shared_docs[\n- \"str_pad\"\n- ] = \"\"\"\n- Pad %(side)s side of strings in the Series/Index.\n-\n- Equivalent to :meth:`str.%(method)s`.\n-\n- Parameters\n- ----------\n- width : int\n- Minimum width of resulting string; additional characters will be filled\n- with ``fillchar``.\n- fillchar : str\n- Additional character for filling, default is whitespace.\n-\n- Returns\n- -------\n- filled : Series/Index of objects.\n- \"\"\"\n-\n- @Appender(_shared_docs[\"str_pad\"] % {\"side\": \"left and right\", \"method\": \"center\"})\n- @forbid_nonstring_types([\"bytes\"])\n- def center(self, width, fillchar=\" \"):\n- return self.pad(width, side=\"both\", fillchar=fillchar)\n-\n- @Appender(_shared_docs[\"str_pad\"] % {\"side\": \"right\", \"method\": \"ljust\"})\n- @forbid_nonstring_types([\"bytes\"])\n- def ljust(self, width, fillchar=\" \"):\n- return self.pad(width, side=\"right\", fillchar=fillchar)\n-\n- @Appender(_shared_docs[\"str_pad\"] % {\"side\": \"left\", \"method\": \"rjust\"})\n- @forbid_nonstring_types([\"bytes\"])\n- def rjust(self, width, fillchar=\" \"):\n- return self.pad(width, side=\"left\", fillchar=fillchar)\n-\n- @forbid_nonstring_types([\"bytes\"])\n- def zfill(self, width):\n- \"\"\"\n- Pad strings in the Series/Index by prepending '0' characters.\n-\n- Strings in the Series/Index are padded with '0' characters on the\n- left of the string to reach a total string length `width`. Strings\n- in the Series/Index with length greater or equal to `width` are\n- unchanged.\n-\n- Parameters\n- ----------\n- width : int\n- Minimum length of resulting string; strings with length less\n- than `width` be prepended with '0' characters.\n-\n- Returns\n- -------\n- Series/Index of objects.\n-\n- See Also\n- --------\n- Series.str.rjust : Fills the left side of strings with an arbitrary\n- character.\n- Series.str.ljust : Fills the right side of strings with an arbitrary\n- character.\n- Series.str.pad : Fills the specified sides of strings with an arbitrary\n- character.\n- Series.str.center : Fills both sides of strings with an arbitrary\n- character.\n-\n- Notes\n- -----\n- Differs from :meth:`str.zfill` which has special handling\n- for '+'/'-' in the string.\n-\n- Examples\n- --------\n- >>> s = pd.Series(['-1', '1', '1000', 10, np.nan])\n- >>> s\n- 0 -1\n- 1 1\n- 2 1000\n- 3 10\n- 4 NaN\n- dtype: object\n-\n- Note that ``10`` and ``NaN`` are not strings, therefore they are\n- converted to ``NaN``. The minus sign in ``'-1'`` is treated as a\n- regular character and the zero is added to the left of it\n- (:meth:`str.zfill` would have moved it to the left). ``1000``\n- remains unchanged as it is longer than `width`.\n-\n- >>> s.str.zfill(3)\n- 0 0-1\n- 1 001\n- 2 1000\n- 3 NaN\n- 4 NaN\n- dtype: object\n- \"\"\"\n- result = self.pad(width, side=\"left\", fillchar=\"0\")\n- return self._wrap_result(result)\n-\n- def slice(self, start=None, stop=None, step=None):\n- \"\"\"\n- Slice substrings from each element in the Series or Index.\n-\n- Parameters\n- ----------\n- start : int, optional\n- Start position for slice operation.\n- stop : int, optional\n- Stop position for slice operation.\n- step : int, optional\n- Step size for slice operation.\n-\n- Returns\n- -------\n- Series or Index of object\n- Series or Index from sliced substring from original string object.\n-\n- See Also\n- --------\n- Series.str.slice_replace : Replace a slice with a string.\n- Series.str.get : Return element at position.\n- Equivalent to `Series.str.slice(start=i, stop=i+1)` with `i`\n- being the position.\n-\n- Examples\n- --------\n- >>> s = pd.Series([\"koala\", \"dog\", \"chameleon\"])\n- >>> s\n- 0 koala\n- 1 dog\n- 2 chameleon\n- dtype: object\n-\n- >>> s.str.slice(start=1)\n- 0 oala\n- 1 og\n- 2 hameleon\n- dtype: object\n-\n- >>> s.str.slice(start=-1)\n- 0 a\n- 1 g\n- 2 n\n- dtype: object\n-\n- >>> s.str.slice(stop=2)\n- 0 ko\n- 1 do\n- 2 ch\n- dtype: object\n-\n- >>> s.str.slice(step=2)\n- 0 kaa\n- 1 dg\n- 2 caeen\n- dtype: object\n-\n- >>> s.str.slice(start=0, stop=5, step=3)\n- 0 kl\n- 1 d\n- 2 cm\n- dtype: object\n-\n- Equivalent behaviour to:\n-\n- >>> s.str[0:5:3]\n- 0 kl\n- 1 d\n- 2 cm\n- dtype: object\n- \"\"\"\n- result = self._data.array._str_slice(start, stop, step)\n- return self._wrap_result(result)\n-\n- @forbid_nonstring_types([\"bytes\"])\n- def slice_replace(self, start=None, stop=None, repl=None):\n- \"\"\"\n- Replace a positional slice of a string with another value.\n-\n- Parameters\n- ----------\n- start : int, optional\n- Left index position to use for the slice. If not specified (None),\n- the slice is unbounded on the left, i.e. slice from the start\n- of the string.\n- stop : int, optional\n- Right index position to use for the slice. If not specified (None),\n- the slice is unbounded on the right, i.e. slice until the\n- end of the string.\n- repl : str, optional\n- String for replacement. If not specified (None), the sliced region\n- is replaced with an empty string.\n-\n- Returns\n- -------\n- Series or Index\n- Same type as the original object.\n-\n- See Also\n- --------\n- Series.str.slice : Just slicing without replacement.\n-\n- Examples\n- --------\n- >>> s = pd.Series(['a', 'ab', 'abc', 'abdc', 'abcde'])\n- >>> s\n- 0 a\n- 1 ab\n- 2 abc\n- 3 abdc\n- 4 abcde\n- dtype: object\n-\n- Specify just `start`, meaning replace `start` until the end of the\n- string with `repl`.\n-\n- >>> s.str.slice_replace(1, repl='X')\n- 0 aX\n- 1 aX\n- 2 aX\n- 3 aX\n- 4 aX\n- dtype: object\n-\n- Specify just `stop`, meaning the start of the string to `stop` is replaced\n- with `repl`, and the rest of the string is included.\n-\n- >>> s.str.slice_replace(stop=2, repl='X')\n- 0 X\n- 1 X\n- 2 Xc\n- 3 Xdc\n- 4 Xcde\n- dtype: object\n-\n- Specify `start` and `stop`, meaning the slice from `start` to `stop` is\n- replaced with `repl`. Everything before or after `start` and `stop` is\n- included as is.\n-\n- >>> s.str.slice_replace(start=1, stop=3, repl='X')\n- 0 aX\n- 1 aX\n- 2 aX\n- 3 aXc\n- 4 aXde\n- dtype: object\n- \"\"\"\n- result = self._data.array._str_slice_replace(start, stop, repl)\n- return self._wrap_result(result)\n-\n- def decode(self, encoding, errors=\"strict\"):\n- \"\"\"\n- Decode character string in the Series/Index using indicated encoding.\n-\n- Equivalent to :meth:`str.decode` in python2 and :meth:`bytes.decode` in\n- python3.\n-\n- Parameters\n- ----------\n- encoding : str\n- errors : str, optional\n-\n- Returns\n- -------\n- Series or Index\n- \"\"\"\n- # TODO: Add a similar _bytes interface.\n- if encoding in _cpython_optimized_decoders:\n- # CPython optimized implementation\n- f = lambda x: x.decode(encoding, errors)\n- else:\n- decoder = codecs.getdecoder(encoding)\n- f = lambda x: decoder(x, errors)[0]\n- arr = self._data.array\n- # assert isinstance(arr, (StringArray,))\n- result = arr._str_map(f)\n- return self._wrap_result(result)\n-\n- @forbid_nonstring_types([\"bytes\"])\n- def encode(self, encoding, errors=\"strict\"):\n- \"\"\"\n- Encode character string in the Series/Index using indicated encoding.\n-\n- Equivalent to :meth:`str.encode`.\n-\n- Parameters\n- ----------\n- encoding : str\n- errors : str, optional\n-\n- Returns\n- -------\n- encoded : Series/Index of objects\n- \"\"\"\n- result = self._data.array._str_encode(encoding, errors)\n- return self._wrap_result(result, returns_string=False)\n-\n- _shared_docs[\n- \"str_strip\"\n- ] = r\"\"\"\n- Remove %(position)s characters.\n-\n- Strip whitespaces (including newlines) or a set of specified characters\n- from each string in the Series/Index from %(side)s.\n- Replaces any non-strings in Series with NaNs.\n- Equivalent to :meth:`str.%(method)s`.\n-\n- Parameters\n- ----------\n- to_strip : str or None, default None\n- Specifying the set of characters to be removed.\n- All combinations of this set of characters will be stripped.\n- If None then whitespaces are removed.\n-\n- Returns\n- -------\n- Series or Index of object\n-\n- See Also\n- --------\n- Series.str.strip : Remove leading and trailing characters in Series/Index.\n- Series.str.lstrip : Remove leading characters in Series/Index.\n- Series.str.rstrip : Remove trailing characters in Series/Index.\n-\n- Examples\n- --------\n- >>> s = pd.Series(['1. Ant. ', '2. Bee!\\n', '3. Cat?\\t', np.nan, 10, True])\n- >>> s\n- 0 1. Ant.\n- 1 2. Bee!\\n\n- 2 3. Cat?\\t\n- 3 NaN\n- 4 10\n- 5 True\n- dtype: object\n-\n- >>> s.str.strip()\n- 0 1. Ant.\n- 1 2. Bee!\n- 2 3. Cat?\n- 3 NaN\n- 4 NaN\n- 5 NaN\n- dtype: object\n-\n- >>> s.str.lstrip('123.')\n- 0 Ant.\n- 1 Bee!\\n\n- 2 Cat?\\t\n- 3 NaN\n- 4 NaN\n- 5 NaN\n- dtype: object\n-\n- >>> s.str.rstrip('.!? \\n\\t')\n- 0 1. Ant\n- 1 2. Bee\n- 2 3. Cat\n- 3 NaN\n- 4 NaN\n- 5 NaN\n- dtype: object\n-\n- >>> s.str.strip('123.!? \\n\\t')\n- 0 Ant\n- 1 Bee\n- 2 Cat\n- 3 NaN\n- 4 NaN\n- 5 NaN\n- dtype: object\n- \"\"\"\n-\n- @Appender(\n- _shared_docs[\"str_strip\"]\n- % {\n- \"side\": \"left and right sides\",\n- \"method\": \"strip\",\n- \"position\": \"leading and trailing\",\n- }\n- )\n- @forbid_nonstring_types([\"bytes\"])\n- def strip(self, to_strip=None):\n- result = self._data.array._str_strip(to_strip)\n- return self._wrap_result(result)\n-\n- @Appender(\n- _shared_docs[\"str_strip\"]\n- % {\"side\": \"left side\", \"method\": \"lstrip\", \"position\": \"leading\"}\n- )\n- @forbid_nonstring_types([\"bytes\"])\n- def lstrip(self, to_strip=None):\n- result = self._data.array._str_lstrip(to_strip)\n- return self._wrap_result(result)\n-\n- @Appender(\n- _shared_docs[\"str_strip\"]\n- % {\"side\": \"right side\", \"method\": \"rstrip\", \"position\": \"trailing\"}\n- )\n- @forbid_nonstring_types([\"bytes\"])\n- def rstrip(self, to_strip=None):\n- result = self._data.array._str_rstrip(to_strip)\n- return self._wrap_result(result)\n-\n- _shared_docs[\n- \"str_removefix\"\n- ] = r\"\"\"\n- Remove a %(side)s from an object series. If the %(side)s is not present,\n- the original string will be returned.\n-\n- Parameters\n- ----------\n- %(side)s : str\n- Remove the %(side)s of the string.\n-\n- Returns\n- -------\n- Series/Index: object\n- The Series or Index with given %(side)s removed.\n-\n- See Also\n- --------\n- Series.str.remove%(other_side)s : Remove a %(other_side)s from an object series.\n-\n- Examples\n- --------\n- >>> s = pd.Series([\"str_foo\", \"str_bar\", \"no_prefix\"])\n- >>> s\n- 0 str_foo\n- 1 str_bar\n- 2 no_prefix\n- dtype: object\n- >>> s.str.removeprefix(\"str_\")\n- 0 foo\n- 1 bar\n- 2 no_prefix\n- dtype: object\n-\n- >>> s = pd.Series([\"foo_str\", \"bar_str\", \"no_suffix\"])\n- >>> s\n- 0 foo_str\n- 1 bar_str\n- 2 no_suffix\n- dtype: object\n- >>> s.str.removesuffix(\"_str\")\n- 0 foo\n- 1 bar\n- 2 no_suffix\n- dtype: object\n- \"\"\"\n-\n- @Appender(\n- _shared_docs[\"str_removefix\"] % {\"side\": \"prefix\", \"other_side\": \"suffix\"}\n- )\n- @forbid_nonstring_types([\"bytes\"])\n- def removeprefix(self, prefix):\n- result = self._data.array._str_removeprefix(prefix)\n- return self._wrap_result(result)\n-\n- @Appender(\n- _shared_docs[\"str_removefix\"] % {\"side\": \"suffix\", \"other_side\": \"prefix\"}\n- )\n- @forbid_nonstring_types([\"bytes\"])\n- def removesuffix(self, suffix):\n- result = self._data.array._str_removesuffix(suffix)\n- return self._wrap_result(result)\n-\n- @forbid_nonstring_types([\"bytes\"])\n- def wrap(self, width, **kwargs):\n- r\"\"\"\n- Wrap strings in Series/Index at specified line width.\n-\n- This method has the same keyword parameters and defaults as\n- :class:`textwrap.TextWrapper`.\n-\n- Parameters\n- ----------\n- width : int\n- Maximum line width.\n- expand_tabs : bool, optional\n- If True, tab characters will be expanded to spaces (default: True).\n- replace_whitespace : bool, optional\n- If True, each whitespace character (as defined by string.whitespace)\n- remaining after tab expansion will be replaced by a single space\n- (default: True).\n- drop_whitespace : bool, optional\n- If True, whitespace that, after wrapping, happens to end up at the\n- beginning or end of a line is dropped (default: True).\n- break_long_words : bool, optional\n- If True, then words longer than width will be broken in order to ensure\n- that no lines are longer than width. If it is false, long words will\n- not be broken, and some lines may be longer than width (default: True).\n- break_on_hyphens : bool, optional\n- If True, wrapping will occur preferably on whitespace and right after\n- hyphens in compound words, as it is customary in English. If false,\n- only whitespaces will be considered as potentially good places for line\n- breaks, but you need to set break_long_words to false if you want truly\n- insecable words (default: True).\n-\n- Returns\n- -------\n- Series or Index\n-\n- Notes\n- -----\n- Internally, this method uses a :class:`textwrap.TextWrapper` instance with\n- default settings. To achieve behavior matching R's stringr library str_wrap\n- function, use the arguments:\n-\n- - expand_tabs = False\n- - replace_whitespace = True\n- - drop_whitespace = True\n- - break_long_words = False\n- - break_on_hyphens = False\n-\n- Examples\n- --------\n- >>> s = pd.Series(['line to be wrapped', 'another line to be wrapped'])\n- >>> s.str.wrap(12)\n- 0 line to be\\nwrapped\n- 1 another line\\nto be\\nwrapped\n- dtype: object\n- \"\"\"\n- result = self._data.array._str_wrap(width, **kwargs)\n- return self._wrap_result(result)\n-\n- @forbid_nonstring_types([\"bytes\"])\n- def get_dummies(self, sep=\"|\"):\n- \"\"\"\n- Return DataFrame of dummy/indicator variables for Series.\n-\n- Each string in Series is split by sep and returned as a DataFrame\n- of dummy/indicator variables.\n-\n- Parameters\n- ----------\n- sep : str, default \"|\"\n- String to split on.\n-\n- Returns\n- -------\n- DataFrame\n- Dummy variables corresponding to values of the Series.\n-\n- See Also\n- --------\n- get_dummies : Convert categorical variable into dummy/indicator\n- variables.\n-\n- Examples\n- --------\n- >>> pd.Series(['a|b', 'a', 'a|c']).str.get_dummies()\n- a b c\n- 0 1 1 0\n- 1 1 0 0\n- 2 1 0 1\n-\n- >>> pd.Series(['a|b', np.nan, 'a|c']).str.get_dummies()\n- a b c\n- 0 1 1 0\n- 1 0 0 0\n- 2 1 0 1\n- \"\"\"\n- # we need to cast to Series of strings as only that has all\n- # methods available for making the dummies...\n- result, name = self._data.array._str_get_dummies(sep)\n- return self._wrap_result(\n- result,\n- name=name,\n- expand=True,\n- returns_string=False,\n- )\n-\n- @forbid_nonstring_types([\"bytes\"])\n- def translate(self, table):\n- \"\"\"\n- Map all characters in the string through the given mapping table.\n-\n- Equivalent to standard :meth:`str.translate`.\n-\n- Parameters\n- ----------\n- table : dict\n- Table is a mapping of Unicode ordinals to Unicode ordinals, strings, or\n- None. Unmapped characters are left untouched.\n- Characters mapped to None are deleted. :meth:`str.maketrans` is a\n- helper function for making translation tables.\n-\n- Returns\n- -------\n- Series or Index\n- \"\"\"\n- result = self._data.array._str_translate(table)\n- return self._wrap_result(result)\n-\n- @forbid_nonstring_types([\"bytes\"])\n- def count(self, pat, flags=0):\n- r\"\"\"\n- Count occurrences of pattern in each string of the Series/Index.\n-\n- This function is used to count the number of times a particular regex\n- pattern is repeated in each of the string elements of the\n- :class:`~pandas.Series`.\n-\n- Parameters\n- ----------\n- pat : str\n- Valid regular expression.\n- flags : int, default 0, meaning no flags\n- Flags for the `re` module. For a complete list, `see here\n- <https://docs.python.org/3/howto/regex.html#compilation-flags>`_.\n- **kwargs\n- For compatibility with other string methods. Not used.\n-\n- Returns\n- -------\n- Series or Index\n- Same type as the calling object containing the integer counts.\n-\n- See Also\n- --------\n- re : Standard library module for regular expressions.\n- str.count : Standard library version, without regular expression support.\n-\n- Notes\n- -----\n- Some characters need to be escaped when passing in `pat`.\n- eg. ``'$'`` has a special meaning in regex and must be escaped when\n- finding this literal character.\n-\n- Examples\n- --------\n- >>> s = pd.Series(['A', 'B', 'Aaba', 'Baca', np.nan, 'CABA', 'cat'])\n- >>> s.str.count('a')\n- 0 0.0\n- 1 0.0\n- 2 2.0\n- 3 2.0\n- 4 NaN\n- 5 0.0\n- 6 1.0\n- dtype: float64\n-\n- Escape ``'$'`` to find the literal dollar sign.\n-\n- >>> s = pd.Series(['$', 'B', 'Aab$', '$$ca', 'C$B$', 'cat'])\n- >>> s.str.count('\\\\$')\n- 0 1\n- 1 0\n- 2 1\n- 3 2\n- 4 2\n- 5 0\n- dtype: int64\n-\n- This is also available on Index\n-\n- >>> pd.Index(['A', 'A', 'Aaba', 'cat']).str.count('a')\n- Int64Index([0, 0, 2, 1], dtype='int64')\n- \"\"\"\n- result = self._data.array._str_count(pat, flags)\n- return self._wrap_result(result, returns_string=False)\n-\n- @forbid_nonstring_types([\"bytes\"])\n- def startswith(self, pat, na=None):\n- \"\"\"\n- Test if the start of each string element matches a pattern.\n-\n- Equivalent to :meth:`str.startswith`.\n-\n- Parameters\n- ----------\n- pat : str\n- Character sequence. Regular expressions are not accepted.\n- na : object, default NaN\n- Object shown if element tested is not a string. The default depends\n- on dtype of the array. For object-dtype, ``numpy.nan`` is used.\n- For ``StringDtype``, ``pandas.NA`` is used.\n-\n- Returns\n- -------\n- Series or Index of bool\n- A Series of booleans indicating whether the given pattern matches\n- the start of each string element.\n-\n- See Also\n- --------\n- str.startswith : Python standard library string method.\n- Series.str.endswith : Same as startswith, but tests the end of string.\n- Series.str.contains : Tests if string element contains a pattern.\n-\n- Examples\n- --------\n- >>> s = pd.Series(['bat', 'Bear', 'cat', np.nan])\n- >>> s\n- 0 bat\n- 1 Bear\n- 2 cat\n- 3 NaN\n- dtype: object\n-\n- >>> s.str.startswith('b')\n- 0 True\n- 1 False\n- 2 False\n- 3 NaN\n- dtype: object\n-\n- Specifying `na` to be `False` instead of `NaN`.\n-\n- >>> s.str.startswith('b', na=False)\n- 0 True\n- 1 False\n- 2 False\n- 3 False\n- dtype: bool\n- \"\"\"\n- if not isinstance(pat, str):\n- msg = f\"expected a string object, not {type(pat).__name__}\"\n- raise TypeError(msg)\n- result = self._data.array._str_startswith(pat, na=na)\n- return self._wrap_result(result, returns_string=False)\n-\n- @forbid_nonstring_types([\"bytes\"])\n- def endswith(self, pat, na=None):\n- \"\"\"\n- Test if the end of each string element matches a pattern.\n-\n- Equivalent to :meth:`str.endswith`.\n-\n- Parameters\n- ----------\n- pat : str\n- Character sequence. Regular expressions are not accepted.\n- na : object, default NaN\n- Object shown if element tested is not a string. The default depends\n- on dtype of the array. For object-dtype, ``numpy.nan`` is used.\n- For ``StringDtype``, ``pandas.NA`` is used.\n-\n- Returns\n- -------\n- Series or Index of bool\n- A Series of booleans indicating whether the given pattern matches\n- the end of each string element.\n-\n- See Also\n- --------\n- str.endswith : Python standard library string method.\n- Series.str.startswith : Same as endswith, but tests the start of string.\n- Series.str.contains : Tests if string element contains a pattern.\n-\n- Examples\n- --------\n- >>> s = pd.Series(['bat', 'bear', 'caT', np.nan])\n- >>> s\n- 0 bat\n- 1 bear\n- 2 caT\n- 3 NaN\n- dtype: object\n-\n- >>> s.str.endswith('t')\n- 0 True\n- 1 False\n- 2 False\n- 3 NaN\n- dtype: object\n-\n- Specifying `na` to be `False` instead of `NaN`.\n-\n- >>> s.str.endswith('t', na=False)\n- 0 True\n- 1 False\n- 2 False\n- 3 False\n- dtype: bool\n- \"\"\"\n- if not isinstance(pat, str):\n- msg = f\"expected a string object, not {type(pat).__name__}\"\n- raise TypeError(msg)\n- result = self._data.array._str_endswith(pat, na=na)\n- return self._wrap_result(result, returns_string=False)\n-\n- @forbid_nonstring_types([\"bytes\"])\n- def findall(self, pat, flags=0):\n- \"\"\"\n- Find all occurrences of pattern or regular expression in the Series/Index.\n-\n- Equivalent to applying :func:`re.findall` to all the elements in the\n- Series/Index.\n-\n- Parameters\n- ----------\n- pat : str\n- Pattern or regular expression.\n- flags : int, default 0\n- Flags from ``re`` module, e.g. `re.IGNORECASE` (default is 0, which\n- means no flags).\n-\n- Returns\n- -------\n- Series/Index of lists of strings\n- All non-overlapping matches of pattern or regular expression in each\n- string of this Series/Index.\n-\n- See Also\n- --------\n- count : Count occurrences of pattern or regular expression in each string\n- of the Series/Index.\n- extractall : For each string in the Series, extract groups from all matches\n- of regular expression and return a DataFrame with one row for each\n- match and one column for each group.\n- re.findall : The equivalent ``re`` function to all non-overlapping matches\n- of pattern or regular expression in string, as a list of strings.\n-\n- Examples\n- --------\n- >>> s = pd.Series(['Lion', 'Monkey', 'Rabbit'])\n-\n- The search for the pattern 'Monkey' returns one match:\n-\n- >>> s.str.findall('Monkey')\n- 0 []\n- 1 [Monkey]\n- 2 []\n- dtype: object\n-\n- On the other hand, the search for the pattern 'MONKEY' doesn't return any\n- match:\n-\n- >>> s.str.findall('MONKEY')\n- 0 []\n- 1 []\n- 2 []\n- dtype: object\n-\n- Flags can be added to the pattern or regular expression. For instance,\n- to find the pattern 'MONKEY' ignoring the case:\n-\n- >>> import re\n- >>> s.str.findall('MONKEY', flags=re.IGNORECASE)\n- 0 []\n- 1 [Monkey]\n- 2 []\n- dtype: object\n-\n- When the pattern matches more than one string in the Series, all matches\n- are returned:\n-\n- >>> s.str.findall('on')\n- 0 [on]\n- 1 [on]\n- 2 []\n- dtype: object\n-\n- Regular expressions are supported too. For instance, the search for all the\n- strings ending with the word 'on' is shown next:\n-\n- >>> s.str.findall('on$')\n- 0 [on]\n- 1 []\n- 2 []\n- dtype: object\n-\n- If the pattern is found more than once in the same string, then a list of\n- multiple strings is returned:\n-\n- >>> s.str.findall('b')\n- 0 []\n- 1 []\n- 2 [b, b]\n- dtype: object\n- \"\"\"\n- result = self._data.array._str_findall(pat, flags)\n- return self._wrap_result(result, returns_string=False)\n-\n- @forbid_nonstring_types([\"bytes\"])\n- def extract(\n- self, pat: str, flags: int = 0, expand: bool = True\n- ) -> DataFrame | Series | Index:\n- r\"\"\"\n- Extract capture groups in the regex `pat` as columns in a DataFrame.\n-\n- For each subject string in the Series, extract groups from the\n- first match of regular expression `pat`.\n-\n- Parameters\n- ----------\n- pat : str\n- Regular expression pattern with capturing groups.\n- flags : int, default 0 (no flags)\n- Flags from the ``re`` module, e.g. ``re.IGNORECASE``, that\n- modify regular expression matching for things like case,\n- spaces, etc. For more details, see :mod:`re`.\n- expand : bool, default True\n- If True, return DataFrame with one column per capture group.\n- If False, return a Series/Index if there is one capture group\n- or DataFrame if there are multiple capture groups.\n-\n- Returns\n- -------\n- DataFrame or Series or Index\n- A DataFrame with one row for each subject string, and one\n- column for each group. Any capture group names in regular\n- expression pat will be used for column names; otherwise\n- capture group numbers will be used. The dtype of each result\n- column is always object, even when no match is found. If\n- ``expand=False`` and pat has only one capture group, then\n- return a Series (if subject is a Series) or Index (if subject\n- is an Index).\n-\n- See Also\n- --------\n- extractall : Returns all matches (not just the first match).\n-\n- Examples\n- --------\n- A pattern with two groups will return a DataFrame with two columns.\n- Non-matches will be NaN.\n-\n- >>> s = pd.Series(['a1', 'b2', 'c3'])\n- >>> s.str.extract(r'([ab])(\\d)')\n- 0 1\n- 0 a 1\n- 1 b 2\n- 2 NaN NaN\n-\n- A pattern may contain optional groups.\n-\n- >>> s.str.extract(r'([ab])?(\\d)')\n- 0 1\n- 0 a 1\n- 1 b 2\n- 2 NaN 3\n-\n- Named groups will become column names in the result.\n-\n- >>> s.str.extract(r'(?P<letter>[ab])(?P<digit>\\d)')\n- letter digit\n- 0 a 1\n- 1 b 2\n- 2 NaN NaN\n-\n- A pattern with one group will return a DataFrame with one column\n- if expand=True.\n-\n- >>> s.str.extract(r'[ab](\\d)', expand=True)\n- 0\n- 0 1\n- 1 2\n- 2 NaN\n-\n- A pattern with one group will return a Series if expand=False.\n-\n- >>> s.str.extract(r'[ab](\\d)', expand=False)\n- 0 1\n- 1 2\n- 2 NaN\n- dtype: object\n- \"\"\"\n- from pandas import DataFrame\n-\n- if not isinstance(expand, bool):\n- raise ValueError(\"expand must be True or False\")\n-\n- regex = re.compile(pat, flags=flags)\n- if regex.groups == 0:\n- raise ValueError(\"pattern contains no capture groups\")\n-\n- if not expand and regex.groups > 1 and isinstance(self._data, ABCIndex):\n- raise ValueError(\"only one regex group is supported with Index\")\n-\n- obj = self._data\n- result_dtype = _result_dtype(obj)\n-\n- returns_df = regex.groups > 1 or expand\n-\n- if returns_df:\n- name = None\n- columns = _get_group_names(regex)\n-\n- if obj.array.size == 0:\n- result = DataFrame(columns=columns, dtype=result_dtype)\n-\n- else:\n- result_list = self._data.array._str_extract(\n- pat, flags=flags, expand=returns_df\n- )\n-\n- result_index: Index | None\n- if isinstance(obj, ABCSeries):\n- result_index = obj.index\n- else:\n- result_index = None\n-\n- result = DataFrame(\n- result_list, columns=columns, index=result_index, dtype=result_dtype\n- )\n-\n- else:\n- name = _get_single_group_name(regex)\n- result = self._data.array._str_extract(pat, flags=flags, expand=returns_df)\n- return self._wrap_result(result, name=name)\n-\n- @forbid_nonstring_types([\"bytes\"])\n- def extractall(self, pat, flags=0):\n- r\"\"\"\n- Extract capture groups in the regex `pat` as columns in DataFrame.\n-\n- For each subject string in the Series, extract groups from all\n- matches of regular expression pat. When each subject string in the\n- Series has exactly one match, extractall(pat).xs(0, level='match')\n- is the same as extract(pat).\n-\n- Parameters\n- ----------\n- pat : str\n- Regular expression pattern with capturing groups.\n- flags : int, default 0 (no flags)\n- A ``re`` module flag, for example ``re.IGNORECASE``. These allow\n- to modify regular expression matching for things like case, spaces,\n- etc. Multiple flags can be combined with the bitwise OR operator,\n- for example ``re.IGNORECASE | re.MULTILINE``.\n-\n- Returns\n- -------\n- DataFrame\n- A ``DataFrame`` with one row for each match, and one column for each\n- group. Its rows have a ``MultiIndex`` with first levels that come from\n- the subject ``Series``. The last level is named 'match' and indexes the\n- matches in each item of the ``Series``. Any capture group names in\n- regular expression pat will be used for column names; otherwise capture\n- group numbers will be used.\n-\n- See Also\n- --------\n- extract : Returns first match only (not all matches).\n-\n- Examples\n- --------\n- A pattern with one group will return a DataFrame with one column.\n- Indices with no matches will not appear in the result.\n-\n- >>> s = pd.Series([\"a1a2\", \"b1\", \"c1\"], index=[\"A\", \"B\", \"C\"])\n- >>> s.str.extractall(r\"[ab](\\d)\")\n- 0\n- match\n- A 0 1\n- 1 2\n- B 0 1\n-\n- Capture group names are used for column names of the result.\n-\n- >>> s.str.extractall(r\"[ab](?P<digit>\\d)\")\n- digit\n- match\n- A 0 1\n- 1 2\n- B 0 1\n-\n- A pattern with two groups will return a DataFrame with two columns.\n-\n- >>> s.str.extractall(r\"(?P<letter>[ab])(?P<digit>\\d)\")\n- letter digit\n- match\n- A 0 a 1\n- 1 a 2\n- B 0 b 1\n-\n- Optional groups that do not match are NaN in the result.\n-\n- >>> s.str.extractall(r\"(?P<letter>[ab])?(?P<digit>\\d)\")\n- letter digit\n- match\n- A 0 a 1\n- 1 a 2\n- B 0 b 1\n- C 0 NaN 1\n- \"\"\"\n- # TODO: dispatch\n- return str_extractall(self._orig, pat, flags)\n-\n- _shared_docs[\n- \"find\"\n- ] = \"\"\"\n- Return %(side)s indexes in each strings in the Series/Index.\n-\n- Each of returned indexes corresponds to the position where the\n- substring is fully contained between [start:end]. Return -1 on\n- failure. Equivalent to standard :meth:`str.%(method)s`.\n-\n- Parameters\n- ----------\n- sub : str\n- Substring being searched.\n- start : int\n- Left edge index.\n- end : int\n- Right edge index.\n-\n- Returns\n- -------\n- Series or Index of int.\n-\n- See Also\n- --------\n- %(also)s\n- \"\"\"\n-\n- @Appender(\n- _shared_docs[\"find\"]\n- % {\n- \"side\": \"lowest\",\n- \"method\": \"find\",\n- \"also\": \"rfind : Return highest indexes in each strings.\",\n- }\n- )\n- @forbid_nonstring_types([\"bytes\"])\n- def find(self, sub, start=0, end=None):\n- if not isinstance(sub, str):\n- msg = f\"expected a string object, not {type(sub).__name__}\"\n- raise TypeError(msg)\n-\n- result = self._data.array._str_find(sub, start, end)\n- return self._wrap_result(result, returns_string=False)\n-\n- @Appender(\n- _shared_docs[\"find\"]\n- % {\n- \"side\": \"highest\",\n- \"method\": \"rfind\",\n- \"also\": \"find : Return lowest indexes in each strings.\",\n- }\n- )\n- @forbid_nonstring_types([\"bytes\"])\n- def rfind(self, sub, start=0, end=None):\n- if not isinstance(sub, str):\n- msg = f\"expected a string object, not {type(sub).__name__}\"\n- raise TypeError(msg)\n-\n- result = self._data.array._str_rfind(sub, start=start, end=end)\n- return self._wrap_result(result, returns_string=False)\n-\n- @forbid_nonstring_types([\"bytes\"])\n- def normalize(self, form):\n- \"\"\"\n- Return the Unicode normal form for the strings in the Series/Index.\n-\n- For more information on the forms, see the\n- :func:`unicodedata.normalize`.\n-\n- Parameters\n- ----------\n- form : {'NFC', 'NFKC', 'NFD', 'NFKD'}\n- Unicode form.\n-\n- Returns\n- -------\n- normalized : Series/Index of objects\n- \"\"\"\n- result = self._data.array._str_normalize(form)\n- return self._wrap_result(result)\n-\n- _shared_docs[\n- \"index\"\n- ] = \"\"\"\n- Return %(side)s indexes in each string in Series/Index.\n-\n- Each of the returned indexes corresponds to the position where the\n- substring is fully contained between [start:end]. This is the same\n- as ``str.%(similar)s`` except instead of returning -1, it raises a\n- ValueError when the substring is not found. Equivalent to standard\n- ``str.%(method)s``.\n-\n- Parameters\n- ----------\n- sub : str\n- Substring being searched.\n- start : int\n- Left edge index.\n- end : int\n- Right edge index.\n-\n- Returns\n- -------\n- Series or Index of object\n-\n- See Also\n- --------\n- %(also)s\n- \"\"\"\n-\n- @Appender(\n- _shared_docs[\"index\"]\n- % {\n- \"side\": \"lowest\",\n- \"similar\": \"find\",\n- \"method\": \"index\",\n- \"also\": \"rindex : Return highest indexes in each strings.\",\n- }\n- )\n- @forbid_nonstring_types([\"bytes\"])\n- def index(self, sub, start=0, end=None):\n- if not isinstance(sub, str):\n- msg = f\"expected a string object, not {type(sub).__name__}\"\n- raise TypeError(msg)\n-\n- result = self._data.array._str_index(sub, start=start, end=end)\n- return self._wrap_result(result, returns_string=False)\n-\n- @Appender(\n- _shared_docs[\"index\"]\n- % {\n- \"side\": \"highest\",\n- \"similar\": \"rfind\",\n- \"method\": \"rindex\",\n- \"also\": \"index : Return lowest indexes in each strings.\",\n- }\n- )\n- @forbid_nonstring_types([\"bytes\"])\n- def rindex(self, sub, start=0, end=None):\n- if not isinstance(sub, str):\n- msg = f\"expected a string object, not {type(sub).__name__}\"\n- raise TypeError(msg)\n-\n- result = self._data.array._str_rindex(sub, start=start, end=end)\n- return self._wrap_result(result, returns_string=False)\n-\n- def len(self):\n- \"\"\"\n- Compute the length of each element in the Series/Index.\n-\n- The element may be a sequence (such as a string, tuple or list) or a collection\n- (such as a dictionary).\n-\n- Returns\n- -------\n- Series or Index of int\n- A Series or Index of integer values indicating the length of each\n- element in the Series or Index.\n-\n- See Also\n- --------\n- str.len : Python built-in function returning the length of an object.\n- Series.size : Returns the length of the Series.\n-\n- Examples\n- --------\n- Returns the length (number of characters) in a string. Returns the\n- number of entries for dictionaries, lists or tuples.\n-\n- >>> s = pd.Series(['dog',\n- ... '',\n- ... 5,\n- ... {'foo' : 'bar'},\n- ... [2, 3, 5, 7],\n- ... ('one', 'two', 'three')])\n- >>> s\n- 0 dog\n- 1\n- 2 5\n- 3 {'foo': 'bar'}\n- 4 [2, 3, 5, 7]\n- 5 (one, two, three)\n- dtype: object\n- >>> s.str.len()\n- 0 3.0\n- 1 0.0\n- 2 NaN\n- 3 1.0\n- 4 4.0\n- 5 3.0\n- dtype: float64\n- \"\"\"\n- result = self._data.array._str_len()\n- return self._wrap_result(result, returns_string=False)\n-\n- _shared_docs[\n- \"casemethods\"\n- ] = \"\"\"\n- Convert strings in the Series/Index to %(type)s.\n- %(version)s\n- Equivalent to :meth:`str.%(method)s`.\n-\n- Returns\n- -------\n- Series or Index of object\n-\n- See Also\n- --------\n- Series.str.lower : Converts all characters to lowercase.\n- Series.str.upper : Converts all characters to uppercase.\n- Series.str.title : Converts first character of each word to uppercase and\n- remaining to lowercase.\n- Series.str.capitalize : Converts first character to uppercase and\n- remaining to lowercase.\n- Series.str.swapcase : Converts uppercase to lowercase and lowercase to\n- uppercase.\n- Series.str.casefold: Removes all case distinctions in the string.\n-\n- Examples\n- --------\n- >>> s = pd.Series(['lower', 'CAPITALS', 'this is a sentence', 'SwApCaSe'])\n- >>> s\n- 0 lower\n- 1 CAPITALS\n- 2 this is a sentence\n- 3 SwApCaSe\n- dtype: object\n-\n- >>> s.str.lower()\n- 0 lower\n- 1 capitals\n- 2 this is a sentence\n- 3 swapcase\n- dtype: object\n-\n- >>> s.str.upper()\n- 0 LOWER\n- 1 CAPITALS\n- 2 THIS IS A SENTENCE\n- 3 SWAPCASE\n- dtype: object\n-\n- >>> s.str.title()\n- 0 Lower\n- 1 Capitals\n- 2 This Is A Sentence\n- 3 Swapcase\n- dtype: object\n-\n- >>> s.str.capitalize()\n- 0 Lower\n- 1 Capitals\n- 2 This is a sentence\n- 3 Swapcase\n- dtype: object\n-\n- >>> s.str.swapcase()\n- 0 LOWER\n- 1 capitals\n- 2 THIS IS A SENTENCE\n- 3 sWaPcAsE\n- dtype: object\n- \"\"\"\n- # Types:\n- # cases:\n- # upper, lower, title, capitalize, swapcase, casefold\n- # boolean:\n- # isalpha, isnumeric isalnum isdigit isdecimal isspace islower isupper istitle\n- # _doc_args holds dict of strings to use in substituting casemethod docs\n- _doc_args: dict[str, dict[str, str]] = {}\n- _doc_args[\"lower\"] = {\"type\": \"lowercase\", \"method\": \"lower\", \"version\": \"\"}\n- _doc_args[\"upper\"] = {\"type\": \"uppercase\", \"method\": \"upper\", \"version\": \"\"}\n- _doc_args[\"title\"] = {\"type\": \"titlecase\", \"method\": \"title\", \"version\": \"\"}\n- _doc_args[\"capitalize\"] = {\n- \"type\": \"be capitalized\",\n- \"method\": \"capitalize\",\n- \"version\": \"\",\n- }\n- _doc_args[\"swapcase\"] = {\n- \"type\": \"be swapcased\",\n- \"method\": \"swapcase\",\n- \"version\": \"\",\n- }\n- _doc_args[\"casefold\"] = {\n- \"type\": \"be casefolded\",\n- \"method\": \"casefold\",\n- \"version\": \"\\n .. versionadded:: 0.25.0\\n\",\n- }\n-\n- @Appender(_shared_docs[\"casemethods\"] % _doc_args[\"lower\"])\n- @forbid_nonstring_types([\"bytes\"])\n- def lower(self):\n- result = self._data.array._str_lower()\n- return self._wrap_result(result)\n-\n- @Appender(_shared_docs[\"casemethods\"] % _doc_args[\"upper\"])\n- @forbid_nonstring_types([\"bytes\"])\n- def upper(self):\n- result = self._data.array._str_upper()\n- return self._wrap_result(result)\n-\n- @Appender(_shared_docs[\"casemethods\"] % _doc_args[\"title\"])\n- @forbid_nonstring_types([\"bytes\"])\n- def title(self):\n- result = self._data.array._str_title()\n- return self._wrap_result(result)\n-\n- @Appender(_shared_docs[\"casemethods\"] % _doc_args[\"capitalize\"])\n- @forbid_nonstring_types([\"bytes\"])\n- def capitalize(self):\n- result = self._data.array._str_capitalize()\n- return self._wrap_result(result)\n-\n- @Appender(_shared_docs[\"casemethods\"] % _doc_args[\"swapcase\"])\n- @forbid_nonstring_types([\"bytes\"])\n- def swapcase(self):\n- result = self._data.array._str_swapcase()\n- return self._wrap_result(result)\n-\n- @Appender(_shared_docs[\"casemethods\"] % _doc_args[\"casefold\"])\n- @forbid_nonstring_types([\"bytes\"])\n- def casefold(self):\n- result = self._data.array._str_casefold()\n- return self._wrap_result(result)\n-\n- _shared_docs[\n- \"ismethods\"\n- ] = \"\"\"\n- Check whether all characters in each string are %(type)s.\n-\n- This is equivalent to running the Python string method\n- :meth:`str.%(method)s` for each element of the Series/Index. If a string\n- has zero characters, ``False`` is returned for that check.\n-\n- Returns\n- -------\n- Series or Index of bool\n- Series or Index of boolean values with the same length as the original\n- Series/Index.\n-\n- See Also\n- --------\n- Series.str.isalpha : Check whether all characters are alphabetic.\n- Series.str.isnumeric : Check whether all characters are numeric.\n- Series.str.isalnum : Check whether all characters are alphanumeric.\n- Series.str.isdigit : Check whether all characters are digits.\n- Series.str.isdecimal : Check whether all characters are decimal.\n- Series.str.isspace : Check whether all characters are whitespace.\n- Series.str.islower : Check whether all characters are lowercase.\n- Series.str.isupper : Check whether all characters are uppercase.\n- Series.str.istitle : Check whether all characters are titlecase.\n-\n- Examples\n- --------\n- **Checks for Alphabetic and Numeric Characters**\n-\n- >>> s1 = pd.Series(['one', 'one1', '1', ''])\n-\n- >>> s1.str.isalpha()\n- 0 True\n- 1 False\n- 2 False\n- 3 False\n- dtype: bool\n-\n- >>> s1.str.isnumeric()\n- 0 False\n- 1 False\n- 2 True\n- 3 False\n- dtype: bool\n-\n- >>> s1.str.isalnum()\n- 0 True\n- 1 True\n- 2 True\n- 3 False\n- dtype: bool\n-\n- Note that checks against characters mixed with any additional punctuation\n- or whitespace will evaluate to false for an alphanumeric check.\n-\n- >>> s2 = pd.Series(['A B', '1.5', '3,000'])\n- >>> s2.str.isalnum()\n- 0 False\n- 1 False\n- 2 False\n- dtype: bool\n-\n- **More Detailed Checks for Numeric Characters**\n-\n- There are several different but overlapping sets of numeric characters that\n- can be checked for.\n-\n- >>> s3 = pd.Series(['23', '³', '⅕', ''])\n-\n- The ``s3.str.isdecimal`` method checks for characters used to form numbers\n- in base 10.\n-\n- >>> s3.str.isdecimal()\n- 0 True\n- 1 False\n- 2 False\n- 3 False\n- dtype: bool\n-\n- The ``s.str.isdigit`` method is the same as ``s3.str.isdecimal`` but also\n- includes special digits, like superscripted and subscripted digits in\n- unicode.\n-\n- >>> s3.str.isdigit()\n- 0 True\n- 1 True\n- 2 False\n- 3 False\n- dtype: bool\n-\n- The ``s.str.isnumeric`` method is the same as ``s3.str.isdigit`` but also\n- includes other characters that can represent quantities such as unicode\n- fractions.\n-\n- >>> s3.str.isnumeric()\n- 0 True\n- 1 True\n- 2 True\n- 3 False\n- dtype: bool\n-\n- **Checks for Whitespace**\n-\n- >>> s4 = pd.Series([' ', '\\\\t\\\\r\\\\n ', ''])\n- >>> s4.str.isspace()\n- 0 True\n- 1 True\n- 2 False\n- dtype: bool\n-\n- **Checks for Character Case**\n-\n- >>> s5 = pd.Series(['leopard', 'Golden Eagle', 'SNAKE', ''])\n-\n- >>> s5.str.islower()\n- 0 True\n- 1 False\n- 2 False\n- 3 False\n- dtype: bool\n-\n- >>> s5.str.isupper()\n- 0 False\n- 1 False\n- 2 True\n- 3 False\n- dtype: bool\n-\n- The ``s5.str.istitle`` method checks for whether all words are in title\n- case (whether only the first letter of each word is capitalized). Words are\n- assumed to be as any sequence of non-numeric characters separated by\n- whitespace characters.\n-\n- >>> s5.str.istitle()\n- 0 False\n- 1 True\n- 2 False\n- 3 False\n- dtype: bool\n- \"\"\"\n- _doc_args[\"isalnum\"] = {\"type\": \"alphanumeric\", \"method\": \"isalnum\"}\n- _doc_args[\"isalpha\"] = {\"type\": \"alphabetic\", \"method\": \"isalpha\"}\n- _doc_args[\"isdigit\"] = {\"type\": \"digits\", \"method\": \"isdigit\"}\n- _doc_args[\"isspace\"] = {\"type\": \"whitespace\", \"method\": \"isspace\"}\n- _doc_args[\"islower\"] = {\"type\": \"lowercase\", \"method\": \"islower\"}\n- _doc_args[\"isupper\"] = {\"type\": \"uppercase\", \"method\": \"isupper\"}\n- _doc_args[\"istitle\"] = {\"type\": \"titlecase\", \"method\": \"istitle\"}\n- _doc_args[\"isnumeric\"] = {\"type\": \"numeric\", \"method\": \"isnumeric\"}\n- _doc_args[\"isdecimal\"] = {\"type\": \"decimal\", \"method\": \"isdecimal\"}\n- # force _noarg_wrapper return type with dtype=np.dtype(bool) (GH 29624)\n-\n- isalnum = _map_and_wrap(\n- \"isalnum\", docstring=_shared_docs[\"ismethods\"] % _doc_args[\"isalnum\"]\n- )\n- isalpha = _map_and_wrap(\n- \"isalpha\", docstring=_shared_docs[\"ismethods\"] % _doc_args[\"isalpha\"]\n- )\n- isdigit = _map_and_wrap(\n- \"isdigit\", docstring=_shared_docs[\"ismethods\"] % _doc_args[\"isdigit\"]\n- )\n- isspace = _map_and_wrap(\n- \"isspace\", docstring=_shared_docs[\"ismethods\"] % _doc_args[\"isspace\"]\n- )\n- islower = _map_and_wrap(\n- \"islower\", docstring=_shared_docs[\"ismethods\"] % _doc_args[\"islower\"]\n- )\n- isupper = _map_and_wrap(\n- \"isupper\", docstring=_shared_docs[\"ismethods\"] % _doc_args[\"isupper\"]\n- )\n- istitle = _map_and_wrap(\n- \"istitle\", docstring=_shared_docs[\"ismethods\"] % _doc_args[\"istitle\"]\n- )\n- isnumeric = _map_and_wrap(\n- \"isnumeric\", docstring=_shared_docs[\"ismethods\"] % _doc_args[\"isnumeric\"]\n- )\n- isdecimal = _map_and_wrap(\n- \"isdecimal\", docstring=_shared_docs[\"ismethods\"] % _doc_args[\"isdecimal\"]\n- )\n-\n-\n-def cat_safe(list_of_columns: list, sep: str):\n- \"\"\"\n- Auxiliary function for :meth:`str.cat`.\n-\n- Same signature as cat_core, but handles TypeErrors in concatenation, which\n- happen if the arrays in list_of columns have the wrong dtypes or content.\n-\n- Parameters\n- ----------\n- list_of_columns : list of numpy arrays\n- List of arrays to be concatenated with sep;\n- these arrays may not contain NaNs!\n- sep : string\n- The separator string for concatenating the columns.\n-\n- Returns\n- -------\n- nd.array\n- The concatenation of list_of_columns with sep.\n- \"\"\"\n- try:\n- result = cat_core(list_of_columns, sep)\n- except TypeError:\n- # if there are any non-string values (wrong dtype or hidden behind\n- # object dtype), np.sum will fail; catch and return with better message\n- for column in list_of_columns:\n- dtype = lib.infer_dtype(column, skipna=True)\n- if dtype not in [\"string\", \"empty\"]:\n- raise TypeError(\n- \"Concatenation requires list-likes containing only \"\n- \"strings (or missing values). Offending values found in \"\n- f\"column {dtype}\"\n- ) from None\n- return result\n-\n-\n-def cat_core(list_of_columns: list, sep: str):\n- \"\"\"\n- Auxiliary function for :meth:`str.cat`\n-\n- Parameters\n- ----------\n- list_of_columns : list of numpy arrays\n- List of arrays to be concatenated with sep;\n- these arrays may not contain NaNs!\n- sep : string\n- The separator string for concatenating the columns.\n-\n- Returns\n- -------\n- nd.array\n- The concatenation of list_of_columns with sep.\n- \"\"\"\n- if sep == \"\":\n- # no need to interleave sep if it is empty\n- arr_of_cols = np.asarray(list_of_columns, dtype=object)\n- return np.sum(arr_of_cols, axis=0)\n- list_with_sep = [sep] * (2 * len(list_of_columns) - 1)\n- list_with_sep[::2] = list_of_columns\n- arr_with_sep = np.asarray(list_with_sep, dtype=object)\n- return np.sum(arr_with_sep, axis=0)\n-\n-\n-def _result_dtype(arr):\n- # workaround #27953\n- # ideally we just pass `dtype=arr.dtype` unconditionally, but this fails\n- # when the list of values is empty.\n- from pandas.core.arrays.string_ import StringDtype\n-\n- if isinstance(arr.dtype, StringDtype):\n- return arr.dtype\n- else:\n- return object\n-\n-\n-def _get_single_group_name(regex: re.Pattern) -> Hashable:\n- if regex.groupindex:\n- return next(iter(regex.groupindex))\n- else:\n- return None\n-\n-\n-def _get_group_names(regex: re.Pattern) -> list[Hashable]:\n- \"\"\"\n- Get named groups from compiled regex.\n-\n- Unnamed groups are numbered.\n-\n- Parameters\n- ----------\n- regex : compiled regex\n-\n- Returns\n- -------\n- list of column labels\n- \"\"\"\n- names = {v: k for k, v in regex.groupindex.items()}\n- return [names.get(1 + i, i) for i in range(regex.groups)]\n-\n-\n-def str_extractall(arr, pat, flags=0):\n- regex = re.compile(pat, flags=flags)\n- # the regex must contain capture groups.\n- if regex.groups == 0:\n- raise ValueError(\"pattern contains no capture groups\")\n-\n- if isinstance(arr, ABCIndex):\n- arr = arr.to_series().reset_index(drop=True)\n-\n- columns = _get_group_names(regex)\n- match_list = []\n- index_list = []\n- is_mi = arr.index.nlevels > 1\n-\n- for subject_key, subject in arr.items():\n- if isinstance(subject, str):\n-\n- if not is_mi:\n- subject_key = (subject_key,)\n-\n- for match_i, match_tuple in enumerate(regex.findall(subject)):\n- if isinstance(match_tuple, str):\n- match_tuple = (match_tuple,)\n- na_tuple = [np.NaN if group == \"\" else group for group in match_tuple]\n- match_list.append(na_tuple)\n- result_key = tuple(subject_key + (match_i,))\n- index_list.append(result_key)\n-\n- from pandas import MultiIndex\n-\n- index = MultiIndex.from_tuples(index_list, names=arr.index.names + [\"match\"])\n- dtype = _result_dtype(arr)\n-\n- result = arr._constructor_expanddim(\n- match_list, index=index, columns=columns, dtype=dtype\n- )\n- return result\n+from pandas._core.strings.accessor import *\ndiff --git a/pandas/core/strings/base.py b/pandas/core/strings/base.py\nindex ef0c3f8c2321d..0a847e7cc6064 100644\n--- a/pandas/core/strings/base.py\n+++ b/pandas/core/strings/base.py\n@@ -1,248 +1 @@\n-from __future__ import annotations\n-\n-import abc\n-from collections.abc import Callable # noqa: PDF001\n-import re\n-from typing import TYPE_CHECKING\n-\n-import numpy as np\n-\n-from pandas._typing import Scalar\n-\n-if TYPE_CHECKING:\n- from pandas import Series\n-\n-\n-class BaseStringArrayMethods(abc.ABC):\n- \"\"\"\n- Base class for extension arrays implementing string methods.\n-\n- This is where our ExtensionArrays can override the implementation of\n- Series.str.<method>. We don't expect this to work with\n- 3rd-party extension arrays.\n-\n- * User calls Series.str.<method>\n- * pandas extracts the extension array from the Series\n- * pandas calls ``extension_array._str_<method>(*args, **kwargs)``\n- * pandas wraps the result, to return to the user.\n-\n- See :ref:`Series.str` for the docstring of each method.\n- \"\"\"\n-\n- def _str_getitem(self, key):\n- if isinstance(key, slice):\n- return self._str_slice(start=key.start, stop=key.stop, step=key.step)\n- else:\n- return self._str_get(key)\n-\n- @abc.abstractmethod\n- def _str_count(self, pat, flags=0):\n- pass\n-\n- @abc.abstractmethod\n- def _str_pad(self, width, side=\"left\", fillchar=\" \"):\n- pass\n-\n- @abc.abstractmethod\n- def _str_contains(self, pat, case=True, flags=0, na=None, regex=True):\n- pass\n-\n- @abc.abstractmethod\n- def _str_startswith(self, pat, na=None):\n- pass\n-\n- @abc.abstractmethod\n- def _str_endswith(self, pat, na=None):\n- pass\n-\n- @abc.abstractmethod\n- def _str_replace(\n- self,\n- pat: str | re.Pattern,\n- repl: str | Callable,\n- n: int = -1,\n- case: bool = True,\n- flags: int = 0,\n- regex: bool = True,\n- ):\n- pass\n-\n- @abc.abstractmethod\n- def _str_repeat(self, repeats):\n- pass\n-\n- @abc.abstractmethod\n- def _str_match(\n- self, pat: str, case: bool = True, flags: int = 0, na: Scalar = np.nan\n- ):\n- pass\n-\n- @abc.abstractmethod\n- def _str_fullmatch(\n- self,\n- pat: str | re.Pattern,\n- case: bool = True,\n- flags: int = 0,\n- na: Scalar = np.nan,\n- ):\n- pass\n-\n- @abc.abstractmethod\n- def _str_encode(self, encoding, errors=\"strict\"):\n- pass\n-\n- @abc.abstractmethod\n- def _str_find(self, sub, start=0, end=None):\n- pass\n-\n- @abc.abstractmethod\n- def _str_rfind(self, sub, start=0, end=None):\n- pass\n-\n- @abc.abstractmethod\n- def _str_findall(self, pat, flags=0):\n- pass\n-\n- @abc.abstractmethod\n- def _str_get(self, i):\n- pass\n-\n- @abc.abstractmethod\n- def _str_index(self, sub, start=0, end=None):\n- pass\n-\n- @abc.abstractmethod\n- def _str_rindex(self, sub, start=0, end=None):\n- pass\n-\n- @abc.abstractmethod\n- def _str_join(self, sep):\n- pass\n-\n- @abc.abstractmethod\n- def _str_partition(self, sep, expand):\n- pass\n-\n- @abc.abstractmethod\n- def _str_rpartition(self, sep, expand):\n- pass\n-\n- @abc.abstractmethod\n- def _str_len(self):\n- pass\n-\n- @abc.abstractmethod\n- def _str_slice(self, start=None, stop=None, step=None):\n- pass\n-\n- @abc.abstractmethod\n- def _str_slice_replace(self, start=None, stop=None, repl=None):\n- pass\n-\n- @abc.abstractmethod\n- def _str_translate(self, table):\n- pass\n-\n- @abc.abstractmethod\n- def _str_wrap(self, width, **kwargs):\n- pass\n-\n- @abc.abstractmethod\n- def _str_get_dummies(self, sep=\"|\"):\n- pass\n-\n- @abc.abstractmethod\n- def _str_isalnum(self):\n- pass\n-\n- @abc.abstractmethod\n- def _str_isalpha(self):\n- pass\n-\n- @abc.abstractmethod\n- def _str_isdecimal(self):\n- pass\n-\n- @abc.abstractmethod\n- def _str_isdigit(self):\n- pass\n-\n- @abc.abstractmethod\n- def _str_islower(self):\n- pass\n-\n- @abc.abstractmethod\n- def _str_isnumeric(self):\n- pass\n-\n- @abc.abstractmethod\n- def _str_isspace(self):\n- pass\n-\n- @abc.abstractmethod\n- def _str_istitle(self):\n- pass\n-\n- @abc.abstractmethod\n- def _str_isupper(self):\n- pass\n-\n- @abc.abstractmethod\n- def _str_capitalize(self):\n- pass\n-\n- @abc.abstractmethod\n- def _str_casefold(self):\n- pass\n-\n- @abc.abstractmethod\n- def _str_title(self):\n- pass\n-\n- @abc.abstractmethod\n- def _str_swapcase(self):\n- pass\n-\n- @abc.abstractmethod\n- def _str_lower(self):\n- pass\n-\n- @abc.abstractmethod\n- def _str_upper(self):\n- pass\n-\n- @abc.abstractmethod\n- def _str_normalize(self, form):\n- pass\n-\n- @abc.abstractmethod\n- def _str_strip(self, to_strip=None):\n- pass\n-\n- @abc.abstractmethod\n- def _str_lstrip(self, to_strip=None):\n- pass\n-\n- @abc.abstractmethod\n- def _str_rstrip(self, to_strip=None):\n- pass\n-\n- @abc.abstractmethod\n- def _str_removeprefix(self, prefix: str) -> Series:\n- pass\n-\n- @abc.abstractmethod\n- def _str_removesuffix(self, suffix: str) -> Series:\n- pass\n-\n- @abc.abstractmethod\n- def _str_split(self, pat=None, n=-1, expand=False):\n- pass\n-\n- @abc.abstractmethod\n- def _str_rsplit(self, pat=None, n=-1):\n- pass\n-\n- @abc.abstractmethod\n- def _str_extract(self, pat: str, flags: int = 0, expand: bool = True):\n- pass\n+from pandas._core.strings.base import *\ndiff --git a/pandas/core/strings/object_array.py b/pandas/core/strings/object_array.py\nindex 7421645baa463..8bf945857f0c0 100644\n--- a/pandas/core/strings/object_array.py\n+++ b/pandas/core/strings/object_array.py\n@@ -1,483 +1 @@\n-from __future__ import annotations\n-\n-from collections.abc import Callable # noqa: PDF001\n-import re\n-import textwrap\n-from typing import TYPE_CHECKING\n-import unicodedata\n-\n-import numpy as np\n-\n-import pandas._libs.lib as lib\n-import pandas._libs.missing as libmissing\n-import pandas._libs.ops as libops\n-from pandas._typing import (\n- NpDtype,\n- Scalar,\n-)\n-\n-from pandas.core.dtypes.common import is_scalar\n-from pandas.core.dtypes.missing import isna\n-\n-from pandas.core.strings.base import BaseStringArrayMethods\n-\n-if TYPE_CHECKING:\n- from pandas import Series\n-\n-\n-class ObjectStringArrayMixin(BaseStringArrayMethods):\n- \"\"\"\n- String Methods operating on object-dtype ndarrays.\n- \"\"\"\n-\n- _str_na_value = np.nan\n-\n- def __len__(self):\n- # For typing, _str_map relies on the object being sized.\n- raise NotImplementedError\n-\n- def _str_map(\n- self, f, na_value=None, dtype: NpDtype | None = None, convert: bool = True\n- ):\n- \"\"\"\n- Map a callable over valid elements of the array.\n-\n- Parameters\n- ----------\n- f : Callable\n- A function to call on each non-NA element.\n- na_value : Scalar, optional\n- The value to set for NA values. Might also be used for the\n- fill value if the callable `f` raises an exception.\n- This defaults to ``self._str_na_value`` which is ``np.nan``\n- for object-dtype and Categorical and ``pd.NA`` for StringArray.\n- dtype : Dtype, optional\n- The dtype of the result array.\n- convert : bool, default True\n- Whether to call `maybe_convert_objects` on the resulting ndarray\n- \"\"\"\n- if dtype is None:\n- dtype = np.dtype(\"object\")\n- if na_value is None:\n- na_value = self._str_na_value\n-\n- if not len(self):\n- return np.array([], dtype=dtype)\n-\n- arr = np.asarray(self, dtype=object)\n- mask = isna(arr)\n- map_convert = convert and not np.all(mask)\n- try:\n- result = lib.map_infer_mask(arr, f, mask.view(np.uint8), map_convert)\n- except (TypeError, AttributeError) as err:\n- # Reraise the exception if callable `f` got wrong number of args.\n- # The user may want to be warned by this, instead of getting NaN\n- p_err = (\n- r\"((takes)|(missing)) (?(2)from \\d+ to )?\\d+ \"\n- r\"(?(3)required )positional arguments?\"\n- )\n-\n- if len(err.args) >= 1 and re.search(p_err, err.args[0]):\n- # FIXME: this should be totally avoidable\n- raise err\n-\n- def g(x):\n- # This type of fallback behavior can be removed once\n- # we remove object-dtype .str accessor.\n- try:\n- return f(x)\n- except (TypeError, AttributeError):\n- return na_value\n-\n- return self._str_map(g, na_value=na_value, dtype=dtype)\n- if not isinstance(result, np.ndarray):\n- return result\n- if na_value is not np.nan:\n- np.putmask(result, mask, na_value)\n- if convert and result.dtype == object:\n- result = lib.maybe_convert_objects(result)\n- return result\n-\n- def _str_count(self, pat, flags=0):\n- regex = re.compile(pat, flags=flags)\n- f = lambda x: len(regex.findall(x))\n- return self._str_map(f, dtype=\"int64\")\n-\n- def _str_pad(self, width, side=\"left\", fillchar=\" \"):\n- if side == \"left\":\n- f = lambda x: x.rjust(width, fillchar)\n- elif side == \"right\":\n- f = lambda x: x.ljust(width, fillchar)\n- elif side == \"both\":\n- f = lambda x: x.center(width, fillchar)\n- else: # pragma: no cover\n- raise ValueError(\"Invalid side\")\n- return self._str_map(f)\n-\n- def _str_contains(self, pat, case=True, flags=0, na=np.nan, regex: bool = True):\n- if regex:\n- if not case:\n- flags |= re.IGNORECASE\n-\n- pat = re.compile(pat, flags=flags)\n-\n- f = lambda x: pat.search(x) is not None\n- else:\n- if case:\n- f = lambda x: pat in x\n- else:\n- upper_pat = pat.upper()\n- f = lambda x: upper_pat in x.upper()\n- return self._str_map(f, na, dtype=np.dtype(\"bool\"))\n-\n- def _str_startswith(self, pat, na=None):\n- f = lambda x: x.startswith(pat)\n- return self._str_map(f, na_value=na, dtype=np.dtype(bool))\n-\n- def _str_endswith(self, pat, na=None):\n- f = lambda x: x.endswith(pat)\n- return self._str_map(f, na_value=na, dtype=np.dtype(bool))\n-\n- def _str_replace(\n- self,\n- pat: str | re.Pattern,\n- repl: str | Callable,\n- n: int = -1,\n- case: bool = True,\n- flags: int = 0,\n- regex: bool = True,\n- ):\n- if case is False:\n- # add case flag, if provided\n- flags |= re.IGNORECASE\n-\n- if regex or flags or callable(repl):\n- if not isinstance(pat, re.Pattern):\n- if regex is False:\n- pat = re.escape(pat)\n- pat = re.compile(pat, flags=flags)\n-\n- n = n if n >= 0 else 0\n- f = lambda x: pat.sub(repl=repl, string=x, count=n)\n- else:\n- f = lambda x: x.replace(pat, repl, n)\n-\n- return self._str_map(f, dtype=str)\n-\n- def _str_repeat(self, repeats):\n- if is_scalar(repeats):\n-\n- def scalar_rep(x):\n- try:\n- return bytes.__mul__(x, repeats)\n- except TypeError:\n- return str.__mul__(x, repeats)\n-\n- return self._str_map(scalar_rep, dtype=str)\n- else:\n- from pandas.core.arrays.string_ import BaseStringArray\n-\n- def rep(x, r):\n- if x is libmissing.NA:\n- return x\n- try:\n- return bytes.__mul__(x, r)\n- except TypeError:\n- return str.__mul__(x, r)\n-\n- repeats = np.asarray(repeats, dtype=object)\n- result = libops.vec_binop(np.asarray(self), repeats, rep)\n- if isinstance(self, BaseStringArray):\n- # Not going through map, so we have to do this here.\n- result = type(self)._from_sequence(result)\n- return result\n-\n- def _str_match(\n- self, pat: str, case: bool = True, flags: int = 0, na: Scalar | None = None\n- ):\n- if not case:\n- flags |= re.IGNORECASE\n-\n- regex = re.compile(pat, flags=flags)\n-\n- f = lambda x: regex.match(x) is not None\n- return self._str_map(f, na_value=na, dtype=np.dtype(bool))\n-\n- def _str_fullmatch(\n- self,\n- pat: str | re.Pattern,\n- case: bool = True,\n- flags: int = 0,\n- na: Scalar | None = None,\n- ):\n- if not case:\n- flags |= re.IGNORECASE\n-\n- regex = re.compile(pat, flags=flags)\n-\n- f = lambda x: regex.fullmatch(x) is not None\n- return self._str_map(f, na_value=na, dtype=np.dtype(bool))\n-\n- def _str_encode(self, encoding, errors=\"strict\"):\n- f = lambda x: x.encode(encoding, errors=errors)\n- return self._str_map(f, dtype=object)\n-\n- def _str_find(self, sub, start=0, end=None):\n- return self._str_find_(sub, start, end, side=\"left\")\n-\n- def _str_rfind(self, sub, start=0, end=None):\n- return self._str_find_(sub, start, end, side=\"right\")\n-\n- def _str_find_(self, sub, start, end, side):\n- if side == \"left\":\n- method = \"find\"\n- elif side == \"right\":\n- method = \"rfind\"\n- else: # pragma: no cover\n- raise ValueError(\"Invalid side\")\n-\n- if end is None:\n- f = lambda x: getattr(x, method)(sub, start)\n- else:\n- f = lambda x: getattr(x, method)(sub, start, end)\n- return self._str_map(f, dtype=\"int64\")\n-\n- def _str_findall(self, pat, flags=0):\n- regex = re.compile(pat, flags=flags)\n- return self._str_map(regex.findall, dtype=\"object\")\n-\n- def _str_get(self, i):\n- def f(x):\n- if isinstance(x, dict):\n- return x.get(i)\n- elif len(x) > i >= -len(x):\n- return x[i]\n- return self._str_na_value\n-\n- return self._str_map(f)\n-\n- def _str_index(self, sub, start=0, end=None):\n- if end:\n- f = lambda x: x.index(sub, start, end)\n- else:\n- f = lambda x: x.index(sub, start, end)\n- return self._str_map(f, dtype=\"int64\")\n-\n- def _str_rindex(self, sub, start=0, end=None):\n- if end:\n- f = lambda x: x.rindex(sub, start, end)\n- else:\n- f = lambda x: x.rindex(sub, start, end)\n- return self._str_map(f, dtype=\"int64\")\n-\n- def _str_join(self, sep):\n- return self._str_map(sep.join)\n-\n- def _str_partition(self, sep, expand):\n- result = self._str_map(lambda x: x.partition(sep), dtype=\"object\")\n- return result\n-\n- def _str_rpartition(self, sep, expand):\n- return self._str_map(lambda x: x.rpartition(sep), dtype=\"object\")\n-\n- def _str_len(self):\n- return self._str_map(len, dtype=\"int64\")\n-\n- def _str_slice(self, start=None, stop=None, step=None):\n- obj = slice(start, stop, step)\n- return self._str_map(lambda x: x[obj])\n-\n- def _str_slice_replace(self, start=None, stop=None, repl=None):\n- if repl is None:\n- repl = \"\"\n-\n- def f(x):\n- if x[start:stop] == \"\":\n- local_stop = start\n- else:\n- local_stop = stop\n- y = \"\"\n- if start is not None:\n- y += x[:start]\n- y += repl\n- if stop is not None:\n- y += x[local_stop:]\n- return y\n-\n- return self._str_map(f)\n-\n- def _str_split(\n- self,\n- pat: str | re.Pattern | None = None,\n- n=-1,\n- expand=False,\n- regex: bool | None = None,\n- ):\n- if pat is None:\n- if n is None or n == 0:\n- n = -1\n- f = lambda x: x.split(pat, n)\n- else:\n- new_pat: str | re.Pattern\n- if regex is True or isinstance(pat, re.Pattern):\n- new_pat = re.compile(pat)\n- elif regex is False:\n- new_pat = pat\n- # regex is None so link to old behavior #43563\n- else:\n- if len(pat) == 1:\n- new_pat = pat\n- else:\n- new_pat = re.compile(pat)\n-\n- if isinstance(new_pat, re.Pattern):\n- if n is None or n == -1:\n- n = 0\n- f = lambda x: new_pat.split(x, maxsplit=n)\n- else:\n- if n is None or n == 0:\n- n = -1\n- f = lambda x: x.split(pat, n)\n- return self._str_map(f, dtype=object)\n-\n- def _str_rsplit(self, pat=None, n=-1):\n- if n is None or n == 0:\n- n = -1\n- f = lambda x: x.rsplit(pat, n)\n- return self._str_map(f, dtype=\"object\")\n-\n- def _str_translate(self, table):\n- return self._str_map(lambda x: x.translate(table))\n-\n- def _str_wrap(self, width, **kwargs):\n- kwargs[\"width\"] = width\n- tw = textwrap.TextWrapper(**kwargs)\n- return self._str_map(lambda s: \"\\n\".join(tw.wrap(s)))\n-\n- def _str_get_dummies(self, sep=\"|\"):\n- from pandas import Series\n-\n- arr = Series(self).fillna(\"\")\n- try:\n- arr = sep + arr + sep\n- except TypeError:\n- arr = sep + arr.astype(str) + sep\n-\n- tags: set[str] = set()\n- for ts in Series(arr).str.split(sep):\n- tags.update(ts)\n- tags2 = sorted(tags - {\"\"})\n-\n- dummies = np.empty((len(arr), len(tags2)), dtype=np.int64)\n-\n- for i, t in enumerate(tags2):\n- pat = sep + t + sep\n- dummies[:, i] = lib.map_infer(arr.to_numpy(), lambda x: pat in x)\n- return dummies, tags2\n-\n- def _str_upper(self):\n- return self._str_map(lambda x: x.upper())\n-\n- def _str_isalnum(self):\n- return self._str_map(str.isalnum, dtype=\"bool\")\n-\n- def _str_isalpha(self):\n- return self._str_map(str.isalpha, dtype=\"bool\")\n-\n- def _str_isdecimal(self):\n- return self._str_map(str.isdecimal, dtype=\"bool\")\n-\n- def _str_isdigit(self):\n- return self._str_map(str.isdigit, dtype=\"bool\")\n-\n- def _str_islower(self):\n- return self._str_map(str.islower, dtype=\"bool\")\n-\n- def _str_isnumeric(self):\n- return self._str_map(str.isnumeric, dtype=\"bool\")\n-\n- def _str_isspace(self):\n- return self._str_map(str.isspace, dtype=\"bool\")\n-\n- def _str_istitle(self):\n- return self._str_map(str.istitle, dtype=\"bool\")\n-\n- def _str_isupper(self):\n- return self._str_map(str.isupper, dtype=\"bool\")\n-\n- def _str_capitalize(self):\n- return self._str_map(str.capitalize)\n-\n- def _str_casefold(self):\n- return self._str_map(str.casefold)\n-\n- def _str_title(self):\n- return self._str_map(str.title)\n-\n- def _str_swapcase(self):\n- return self._str_map(str.swapcase)\n-\n- def _str_lower(self):\n- return self._str_map(str.lower)\n-\n- def _str_normalize(self, form):\n- f = lambda x: unicodedata.normalize(form, x)\n- return self._str_map(f)\n-\n- def _str_strip(self, to_strip=None):\n- return self._str_map(lambda x: x.strip(to_strip))\n-\n- def _str_lstrip(self, to_strip=None):\n- return self._str_map(lambda x: x.lstrip(to_strip))\n-\n- def _str_rstrip(self, to_strip=None):\n- return self._str_map(lambda x: x.rstrip(to_strip))\n-\n- def _str_removeprefix(self, prefix: str) -> Series:\n- # outstanding question on whether to use native methods for users on Python 3.9+\n- # https://github.com/pandas-dev/pandas/pull/39226#issuecomment-836719770,\n- # in which case we could do return self._str_map(str.removeprefix)\n-\n- def removeprefix(text: str) -> str:\n- if text.startswith(prefix):\n- return text[len(prefix) :]\n- return text\n-\n- return self._str_map(removeprefix)\n-\n- def _str_removesuffix(self, suffix: str) -> Series:\n- # this could be used on Python 3.9+\n- # f = lambda x: x.removesuffix(suffix)\n- # return self._str_map(str.removesuffix)\n-\n- def removesuffix(text: str) -> str:\n- if text.endswith(suffix):\n- return text[: -len(suffix)]\n- return text\n-\n- return self._str_map(removesuffix)\n-\n- def _str_extract(self, pat: str, flags: int = 0, expand: bool = True):\n- regex = re.compile(pat, flags=flags)\n- na_value = self._str_na_value\n-\n- if not expand:\n-\n- def g(x):\n- m = regex.search(x)\n- return m.groups()[0] if m else na_value\n-\n- return self._str_map(g, convert=False)\n-\n- empty_row = [na_value] * regex.groups\n-\n- def f(x):\n- if not isinstance(x, str):\n- return empty_row\n- m = regex.search(x)\n- if m:\n- return [na_value if item is None else item for item in m.groups()]\n- else:\n- return empty_row\n-\n- return [f(val) for val in np.asarray(self)]\n+from pandas._core.strings.object_array import *\ndiff --git a/pandas/core/tools/__init__.py b/pandas/core/tools/__init__.py\nindex e69de29bb2d1d..f696b5a135a04 100644\n--- a/pandas/core/tools/__init__.py\n+++ b/pandas/core/tools/__init__.py\n@@ -0,0 +1 @@\n+from pandas._core.tools.__init__ import *\ndiff --git a/pandas/core/tools/datetimes.py b/pandas/core/tools/datetimes.py\nindex d4d61df915acb..68dbeea59c4da 100644\n--- a/pandas/core/tools/datetimes.py\n+++ b/pandas/core/tools/datetimes.py\n@@ -1,1291 +1 @@\n-from __future__ import annotations\n-\n-from collections import abc\n-from datetime import datetime\n-from functools import partial\n-from itertools import islice\n-from typing import (\n- TYPE_CHECKING,\n- Callable,\n- Hashable,\n- List,\n- Tuple,\n- TypedDict,\n- Union,\n- cast,\n- overload,\n-)\n-import warnings\n-\n-import numpy as np\n-\n-from pandas._libs import tslib\n-from pandas._libs.tslibs import (\n- OutOfBoundsDatetime,\n- Timedelta,\n- Timestamp,\n- iNaT,\n- nat_strings,\n- parsing,\n- timezones,\n-)\n-from pandas._libs.tslibs.parsing import ( # noqa:F401\n- DateParseError,\n- format_is_iso,\n- guess_datetime_format,\n-)\n-from pandas._libs.tslibs.strptime import array_strptime\n-from pandas._typing import (\n- AnyArrayLike,\n- ArrayLike,\n- DateTimeErrorChoices,\n- Timezone,\n- npt,\n-)\n-from pandas.util._exceptions import find_stack_level\n-\n-from pandas.core.dtypes.common import (\n- ensure_object,\n- is_datetime64_dtype,\n- is_datetime64_ns_dtype,\n- is_datetime64tz_dtype,\n- is_float,\n- is_integer,\n- is_integer_dtype,\n- is_list_like,\n- is_numeric_dtype,\n- is_scalar,\n-)\n-from pandas.core.dtypes.generic import (\n- ABCDataFrame,\n- ABCSeries,\n-)\n-from pandas.core.dtypes.missing import notna\n-\n-from pandas.arrays import (\n- DatetimeArray,\n- IntegerArray,\n-)\n-from pandas.core import algorithms\n-from pandas.core.algorithms import unique\n-from pandas.core.arrays.base import ExtensionArray\n-from pandas.core.arrays.datetimes import (\n- maybe_convert_dtype,\n- objects_to_datetime64ns,\n- tz_to_dtype,\n-)\n-from pandas.core.construction import extract_array\n-from pandas.core.indexes.base import Index\n-from pandas.core.indexes.datetimes import DatetimeIndex\n-\n-if TYPE_CHECKING:\n- from pandas._libs.tslibs.nattype import NaTType\n- from pandas._libs.tslibs.timedeltas import UnitChoices\n-\n- from pandas import (\n- DataFrame,\n- Series,\n- )\n-\n-# ---------------------------------------------------------------------\n-# types used in annotations\n-\n-ArrayConvertible = Union[List, Tuple, AnyArrayLike]\n-Scalar = Union[int, float, str]\n-DatetimeScalar = Union[Scalar, datetime]\n-\n-DatetimeScalarOrArrayConvertible = Union[DatetimeScalar, ArrayConvertible]\n-\n-DatetimeDictArg = Union[List[Scalar], Tuple[Scalar, ...], AnyArrayLike]\n-\n-\n-class YearMonthDayDict(TypedDict, total=True):\n- year: DatetimeDictArg\n- month: DatetimeDictArg\n- day: DatetimeDictArg\n-\n-\n-class FulldatetimeDict(YearMonthDayDict, total=False):\n- hour: DatetimeDictArg\n- hours: DatetimeDictArg\n- minute: DatetimeDictArg\n- minutes: DatetimeDictArg\n- second: DatetimeDictArg\n- seconds: DatetimeDictArg\n- ms: DatetimeDictArg\n- us: DatetimeDictArg\n- ns: DatetimeDictArg\n-\n-\n-DictConvertible = Union[FulldatetimeDict, \"DataFrame\"]\n-start_caching_at = 50\n-\n-\n-# ---------------------------------------------------------------------\n-\n-\n-def _guess_datetime_format_for_array(arr, dayfirst: bool | None = False):\n- # Try to guess the format based on the first non-NaN element\n- non_nan_elements = notna(arr).nonzero()[0]\n- if len(non_nan_elements):\n- return guess_datetime_format(arr[non_nan_elements[0]], dayfirst=dayfirst)\n-\n-\n-def should_cache(\n- arg: ArrayConvertible, unique_share: float = 0.7, check_count: int | None = None\n-) -> bool:\n- \"\"\"\n- Decides whether to do caching.\n-\n- If the percent of unique elements among `check_count` elements less\n- than `unique_share * 100` then we can do caching.\n-\n- Parameters\n- ----------\n- arg: listlike, tuple, 1-d array, Series\n- unique_share: float, default=0.7, optional\n- 0 < unique_share < 1\n- check_count: int, optional\n- 0 <= check_count <= len(arg)\n-\n- Returns\n- -------\n- do_caching: bool\n-\n- Notes\n- -----\n- By default for a sequence of less than 50 items in size, we don't do\n- caching; for the number of elements less than 5000, we take ten percent of\n- all elements to check for a uniqueness share; if the sequence size is more\n- than 5000, then we check only the first 500 elements.\n- All constants were chosen empirically by.\n- \"\"\"\n- do_caching = True\n-\n- # default realization\n- if check_count is None:\n- # in this case, the gain from caching is negligible\n- if len(arg) <= start_caching_at:\n- return False\n-\n- if len(arg) <= 5000:\n- check_count = len(arg) // 10\n- else:\n- check_count = 500\n- else:\n- assert (\n- 0 <= check_count <= len(arg)\n- ), \"check_count must be in next bounds: [0; len(arg)]\"\n- if check_count == 0:\n- return False\n-\n- assert 0 < unique_share < 1, \"unique_share must be in next bounds: (0; 1)\"\n-\n- try:\n- # We can't cache if the items are not hashable.\n- unique_elements = set(islice(arg, check_count))\n- except TypeError:\n- return False\n- if len(unique_elements) > check_count * unique_share:\n- do_caching = False\n- return do_caching\n-\n-\n-def _maybe_cache(\n- arg: ArrayConvertible,\n- format: str | None,\n- cache: bool,\n- convert_listlike: Callable,\n-) -> Series:\n- \"\"\"\n- Create a cache of unique dates from an array of dates\n-\n- Parameters\n- ----------\n- arg : listlike, tuple, 1-d array, Series\n- format : string\n- Strftime format to parse time\n- cache : bool\n- True attempts to create a cache of converted values\n- convert_listlike : function\n- Conversion function to apply on dates\n-\n- Returns\n- -------\n- cache_array : Series\n- Cache of converted, unique dates. Can be empty\n- \"\"\"\n- from pandas import Series\n-\n- cache_array = Series(dtype=object)\n-\n- if cache:\n- # Perform a quicker unique check\n- if not should_cache(arg):\n- return cache_array\n-\n- unique_dates = unique(arg)\n- if len(unique_dates) < len(arg):\n- cache_dates = convert_listlike(unique_dates, format)\n- cache_array = Series(cache_dates, index=unique_dates)\n- # GH#39882 and GH#35888 in case of None and NaT we get duplicates\n- if not cache_array.index.is_unique:\n- cache_array = cache_array[~cache_array.index.duplicated()]\n- return cache_array\n-\n-\n-def _box_as_indexlike(\n- dt_array: ArrayLike, utc: bool | None = None, name: Hashable = None\n-) -> Index:\n- \"\"\"\n- Properly boxes the ndarray of datetimes to DatetimeIndex\n- if it is possible or to generic Index instead\n-\n- Parameters\n- ----------\n- dt_array: 1-d array\n- Array of datetimes to be wrapped in an Index.\n- tz : object\n- None or 'utc'\n- name : string, default None\n- Name for a resulting index\n-\n- Returns\n- -------\n- result : datetime of converted dates\n- - DatetimeIndex if convertible to sole datetime64 type\n- - general Index otherwise\n- \"\"\"\n-\n- if is_datetime64_dtype(dt_array):\n- tz = \"utc\" if utc else None\n- return DatetimeIndex(dt_array, tz=tz, name=name)\n- return Index(dt_array, name=name, dtype=dt_array.dtype)\n-\n-\n-def _convert_and_box_cache(\n- arg: DatetimeScalarOrArrayConvertible,\n- cache_array: Series,\n- name: str | None = None,\n-) -> Index:\n- \"\"\"\n- Convert array of dates with a cache and wrap the result in an Index.\n-\n- Parameters\n- ----------\n- arg : integer, float, string, datetime, list, tuple, 1-d array, Series\n- cache_array : Series\n- Cache of converted, unique dates\n- name : string, default None\n- Name for a DatetimeIndex\n-\n- Returns\n- -------\n- result : Index-like of converted dates\n- \"\"\"\n- from pandas import Series\n-\n- result = Series(arg).map(cache_array)\n- return _box_as_indexlike(result._values, utc=None, name=name)\n-\n-\n-def _return_parsed_timezone_results(result: np.ndarray, timezones, tz, name) -> Index:\n- \"\"\"\n- Return results from array_strptime if a %z or %Z directive was passed.\n-\n- Parameters\n- ----------\n- result : ndarray[int64]\n- int64 date representations of the dates\n- timezones : ndarray\n- pytz timezone objects\n- tz : object\n- None or pytz timezone object\n- name : string, default None\n- Name for a DatetimeIndex\n-\n- Returns\n- -------\n- tz_result : Index-like of parsed dates with timezone\n- \"\"\"\n- tz_results = np.array(\n- [Timestamp(res).tz_localize(zone) for res, zone in zip(result, timezones)]\n- )\n- if tz is not None:\n- # Convert to the same tz\n- tz_results = np.array([tz_result.tz_convert(tz) for tz_result in tz_results])\n-\n- return Index(tz_results, name=name)\n-\n-\n-def _convert_listlike_datetimes(\n- arg,\n- format: str | None,\n- name: Hashable = None,\n- tz: Timezone | None = None,\n- unit: str | None = None,\n- errors: str = \"raise\",\n- infer_datetime_format: bool = False,\n- dayfirst: bool | None = None,\n- yearfirst: bool | None = None,\n- exact: bool = True,\n-):\n- \"\"\"\n- Helper function for to_datetime. Performs the conversions of 1D listlike\n- of dates\n-\n- Parameters\n- ----------\n- arg : list, tuple, ndarray, Series, Index\n- date to be parsed\n- name : object\n- None or string for the Index name\n- tz : object\n- None or 'utc'\n- unit : str\n- None or string of the frequency of the passed data\n- errors : str\n- error handing behaviors from to_datetime, 'raise', 'coerce', 'ignore'\n- infer_datetime_format : bool, default False\n- inferring format behavior from to_datetime\n- dayfirst : bool\n- dayfirst parsing behavior from to_datetime\n- yearfirst : bool\n- yearfirst parsing behavior from to_datetime\n- exact : bool, default True\n- exact format matching behavior from to_datetime\n-\n- Returns\n- -------\n- Index-like of parsed dates\n- \"\"\"\n- if isinstance(arg, (list, tuple)):\n- arg = np.array(arg, dtype=\"O\")\n-\n- arg_dtype = getattr(arg, \"dtype\", None)\n- # these are shortcutable\n- if is_datetime64tz_dtype(arg_dtype):\n- if not isinstance(arg, (DatetimeArray, DatetimeIndex)):\n- return DatetimeIndex(arg, tz=tz, name=name)\n- if tz == \"utc\":\n- arg = arg.tz_convert(None).tz_localize(tz)\n- return arg\n-\n- elif is_datetime64_ns_dtype(arg_dtype):\n- if not isinstance(arg, (DatetimeArray, DatetimeIndex)):\n- try:\n- return DatetimeIndex(arg, tz=tz, name=name)\n- except ValueError:\n- pass\n- elif tz:\n- # DatetimeArray, DatetimeIndex\n- return arg.tz_localize(tz)\n-\n- return arg\n-\n- elif unit is not None:\n- if format is not None:\n- raise ValueError(\"cannot specify both format and unit\")\n- return _to_datetime_with_unit(arg, unit, name, tz, errors)\n- elif getattr(arg, \"ndim\", 1) > 1:\n- raise TypeError(\n- \"arg must be a string, datetime, list, tuple, 1-d array, or Series\"\n- )\n-\n- # warn if passing timedelta64, raise for PeriodDtype\n- # NB: this must come after unit transformation\n- orig_arg = arg\n- try:\n- arg, _ = maybe_convert_dtype(arg, copy=False, tz=timezones.maybe_get_tz(tz))\n- except TypeError:\n- if errors == \"coerce\":\n- npvalues = np.array([\"NaT\"], dtype=\"datetime64[ns]\").repeat(len(arg))\n- return DatetimeIndex(npvalues, name=name)\n- elif errors == \"ignore\":\n- idx = Index(arg, name=name)\n- return idx\n- raise\n-\n- arg = ensure_object(arg)\n- require_iso8601 = False\n-\n- if infer_datetime_format and format is None:\n- format = _guess_datetime_format_for_array(arg, dayfirst=dayfirst)\n-\n- if format is not None:\n- # There is a special fast-path for iso8601 formatted\n- # datetime strings, so in those cases don't use the inferred\n- # format because this path makes process slower in this\n- # special case\n- format_is_iso8601 = format_is_iso(format)\n- if format_is_iso8601:\n- require_iso8601 = not infer_datetime_format\n- format = None\n-\n- if format is not None:\n- res = _to_datetime_with_format(\n- arg, orig_arg, name, tz, format, exact, errors, infer_datetime_format\n- )\n- if res is not None:\n- return res\n-\n- assert format is None or infer_datetime_format\n- utc = tz == \"utc\"\n- result, tz_parsed = objects_to_datetime64ns(\n- arg,\n- dayfirst=dayfirst,\n- yearfirst=yearfirst,\n- utc=utc,\n- errors=errors,\n- require_iso8601=require_iso8601,\n- allow_object=True,\n- )\n-\n- if tz_parsed is not None:\n- # We can take a shortcut since the datetime64 numpy array\n- # is in UTC\n- dta = DatetimeArray(result, dtype=tz_to_dtype(tz_parsed))\n- return DatetimeIndex._simple_new(dta, name=name)\n-\n- utc = tz == \"utc\"\n- return _box_as_indexlike(result, utc=utc, name=name)\n-\n-\n-def _array_strptime_with_fallback(\n- arg,\n- name,\n- tz,\n- fmt: str,\n- exact: bool,\n- errors: str,\n- infer_datetime_format: bool,\n-) -> Index | None:\n- \"\"\"\n- Call array_strptime, with fallback behavior depending on 'errors'.\n- \"\"\"\n- utc = tz == \"utc\"\n-\n- try:\n- result, timezones = array_strptime(arg, fmt, exact=exact, errors=errors)\n- except OutOfBoundsDatetime:\n- if errors == \"raise\":\n- raise\n- elif errors == \"coerce\":\n- result = np.empty(arg.shape, dtype=\"M8[ns]\")\n- iresult = result.view(\"i8\")\n- iresult.fill(iNaT)\n- else:\n- result = arg\n- except ValueError:\n- # if fmt was inferred, try falling back\n- # to array_to_datetime - terminate here\n- # for specified formats\n- if not infer_datetime_format:\n- if errors == \"raise\":\n- raise\n- elif errors == \"coerce\":\n- result = np.empty(arg.shape, dtype=\"M8[ns]\")\n- iresult = result.view(\"i8\")\n- iresult.fill(iNaT)\n- else:\n- result = arg\n- else:\n- # Indicates to the caller to fallback to objects_to_datetime64ns\n- return None\n- else:\n- if \"%Z\" in fmt or \"%z\" in fmt:\n- return _return_parsed_timezone_results(result, timezones, tz, name)\n-\n- return _box_as_indexlike(result, utc=utc, name=name)\n-\n-\n-def _to_datetime_with_format(\n- arg,\n- orig_arg,\n- name,\n- tz,\n- fmt: str,\n- exact: bool,\n- errors: str,\n- infer_datetime_format: bool,\n-) -> Index | None:\n- \"\"\"\n- Try parsing with the given format, returning None on failure.\n- \"\"\"\n- result = None\n-\n- # shortcut formatting here\n- if fmt == \"%Y%m%d\":\n- # pass orig_arg as float-dtype may have been converted to\n- # datetime64[ns]\n- orig_arg = ensure_object(orig_arg)\n- try:\n- # may return None without raising\n- result = _attempt_YYYYMMDD(orig_arg, errors=errors)\n- except (ValueError, TypeError, OutOfBoundsDatetime) as err:\n- raise ValueError(\n- \"cannot convert the input to '%Y%m%d' date format\"\n- ) from err\n- if result is not None:\n- utc = tz == \"utc\"\n- return _box_as_indexlike(result, utc=utc, name=name)\n-\n- # fallback\n- res = _array_strptime_with_fallback(\n- arg, name, tz, fmt, exact, errors, infer_datetime_format\n- )\n- return res\n-\n-\n-def _to_datetime_with_unit(arg, unit, name, tz, errors: str) -> Index:\n- \"\"\"\n- to_datetime specalized to the case where a 'unit' is passed.\n- \"\"\"\n- arg = extract_array(arg, extract_numpy=True)\n-\n- # GH#30050 pass an ndarray to tslib.array_with_unit_to_datetime\n- # because it expects an ndarray argument\n- if isinstance(arg, IntegerArray):\n- arr = arg.astype(f\"datetime64[{unit}]\")\n- tz_parsed = None\n- else:\n- arg = np.asarray(arg)\n- arr, tz_parsed = tslib.array_with_unit_to_datetime(arg, unit, errors=errors)\n-\n- if errors == \"ignore\":\n- # Index constructor _may_ infer to DatetimeIndex\n- result = Index._with_infer(arr, name=name)\n- else:\n- result = DatetimeIndex(arr, name=name)\n-\n- if not isinstance(result, DatetimeIndex):\n- return result\n-\n- # GH#23758: We may still need to localize the result with tz\n- # GH#25546: Apply tz_parsed first (from arg), then tz (from caller)\n- # result will be naive but in UTC\n- result = result.tz_localize(\"UTC\").tz_convert(tz_parsed)\n-\n- if tz is not None:\n- if result.tz is None:\n- result = result.tz_localize(tz)\n- else:\n- result = result.tz_convert(tz)\n- return result\n-\n-\n-def _adjust_to_origin(arg, origin, unit):\n- \"\"\"\n- Helper function for to_datetime.\n- Adjust input argument to the specified origin\n-\n- Parameters\n- ----------\n- arg : list, tuple, ndarray, Series, Index\n- date to be adjusted\n- origin : 'julian' or Timestamp\n- origin offset for the arg\n- unit : str\n- passed unit from to_datetime, must be 'D'\n-\n- Returns\n- -------\n- ndarray or scalar of adjusted date(s)\n- \"\"\"\n- if origin == \"julian\":\n- original = arg\n- j0 = Timestamp(0).to_julian_date()\n- if unit != \"D\":\n- raise ValueError(\"unit must be 'D' for origin='julian'\")\n- try:\n- arg = arg - j0\n- except TypeError as err:\n- raise ValueError(\n- \"incompatible 'arg' type for given 'origin'='julian'\"\n- ) from err\n-\n- # preemptively check this for a nice range\n- j_max = Timestamp.max.to_julian_date() - j0\n- j_min = Timestamp.min.to_julian_date() - j0\n- if np.any(arg > j_max) or np.any(arg < j_min):\n- raise OutOfBoundsDatetime(\n- f\"{original} is Out of Bounds for origin='julian'\"\n- )\n- else:\n- # arg must be numeric\n- if not (\n- (is_scalar(arg) and (is_integer(arg) or is_float(arg)))\n- or is_numeric_dtype(np.asarray(arg))\n- ):\n- raise ValueError(\n- f\"'{arg}' is not compatible with origin='{origin}'; \"\n- \"it must be numeric with a unit specified\"\n- )\n-\n- # we are going to offset back to unix / epoch time\n- try:\n- offset = Timestamp(origin)\n- except OutOfBoundsDatetime as err:\n- raise OutOfBoundsDatetime(f\"origin {origin} is Out of Bounds\") from err\n- except ValueError as err:\n- raise ValueError(\n- f\"origin {origin} cannot be converted to a Timestamp\"\n- ) from err\n-\n- if offset.tz is not None:\n- raise ValueError(f\"origin offset {offset} must be tz-naive\")\n- td_offset = offset - Timestamp(0)\n-\n- # convert the offset to the unit of the arg\n- # this should be lossless in terms of precision\n- ioffset = td_offset // Timedelta(1, unit=unit)\n-\n- # scalars & ndarray-like can handle the addition\n- if is_list_like(arg) and not isinstance(arg, (ABCSeries, Index, np.ndarray)):\n- arg = np.asarray(arg)\n- arg = arg + ioffset\n- return arg\n-\n-\n-@overload\n-def to_datetime(\n- arg: DatetimeScalar,\n- errors: DateTimeErrorChoices = ...,\n- dayfirst: bool = ...,\n- yearfirst: bool = ...,\n- utc: bool | None = ...,\n- format: str | None = ...,\n- exact: bool = ...,\n- unit: str | None = ...,\n- infer_datetime_format: bool = ...,\n- origin=...,\n- cache: bool = ...,\n-) -> Timestamp:\n- ...\n-\n-\n-@overload\n-def to_datetime(\n- arg: Series | DictConvertible,\n- errors: DateTimeErrorChoices = ...,\n- dayfirst: bool = ...,\n- yearfirst: bool = ...,\n- utc: bool | None = ...,\n- format: str | None = ...,\n- exact: bool = ...,\n- unit: str | None = ...,\n- infer_datetime_format: bool = ...,\n- origin=...,\n- cache: bool = ...,\n-) -> Series:\n- ...\n-\n-\n-@overload\n-def to_datetime(\n- arg: list | tuple | Index | ArrayLike,\n- errors: DateTimeErrorChoices = ...,\n- dayfirst: bool = ...,\n- yearfirst: bool = ...,\n- utc: bool | None = ...,\n- format: str | None = ...,\n- exact: bool = ...,\n- unit: str | None = ...,\n- infer_datetime_format: bool = ...,\n- origin=...,\n- cache: bool = ...,\n-) -> DatetimeIndex:\n- ...\n-\n-\n-def to_datetime(\n- arg: DatetimeScalarOrArrayConvertible | DictConvertible,\n- errors: DateTimeErrorChoices = \"raise\",\n- dayfirst: bool = False,\n- yearfirst: bool = False,\n- utc: bool | None = None,\n- format: str | None = None,\n- exact: bool = True,\n- unit: str | None = None,\n- infer_datetime_format: bool = False,\n- origin=\"unix\",\n- cache: bool = True,\n-) -> DatetimeIndex | Series | DatetimeScalar | NaTType | None:\n- \"\"\"\n- Convert argument to datetime.\n-\n- This function converts a scalar, array-like, :class:`Series` or\n- :class:`DataFrame`/dict-like to a pandas datetime object.\n-\n- Parameters\n- ----------\n- arg : int, float, str, datetime, list, tuple, 1-d array, Series, DataFrame/dict-like\n- The object to convert to a datetime. If a :class:`DataFrame` is provided, the\n- method expects minimally the following columns: :const:`\"year\"`,\n- :const:`\"month\"`, :const:`\"day\"`.\n- errors : {'ignore', 'raise', 'coerce'}, default 'raise'\n- - If :const:`'raise'`, then invalid parsing will raise an exception.\n- - If :const:`'coerce'`, then invalid parsing will be set as :const:`NaT`.\n- - If :const:`'ignore'`, then invalid parsing will return the input.\n- dayfirst : bool, default False\n- Specify a date parse order if `arg` is str or is list-like.\n- If :const:`True`, parses dates with the day first, e.g. :const:`\"10/11/12\"`\n- is parsed as :const:`2012-11-10`.\n-\n- .. warning::\n-\n- ``dayfirst=True`` is not strict, but will prefer to parse\n- with day first. If a delimited date string cannot be parsed in\n- accordance with the given `dayfirst` option, e.g.\n- ``to_datetime(['31-12-2021'])``, then a warning will be shown.\n-\n- yearfirst : bool, default False\n- Specify a date parse order if `arg` is str or is list-like.\n-\n- - If :const:`True` parses dates with the year first, e.g.\n- :const:`\"10/11/12\"` is parsed as :const:`2010-11-12`.\n- - If both `dayfirst` and `yearfirst` are :const:`True`, `yearfirst` is\n- preceded (same as :mod:`dateutil`).\n-\n- .. warning::\n-\n- ``yearfirst=True`` is not strict, but will prefer to parse\n- with year first.\n-\n- utc : bool, default None\n- Control timezone-related parsing, localization and conversion.\n-\n- - If :const:`True`, the function *always* returns a timezone-aware\n- UTC-localized :class:`Timestamp`, :class:`Series` or\n- :class:`DatetimeIndex`. To do this, timezone-naive inputs are\n- *localized* as UTC, while timezone-aware inputs are *converted* to UTC.\n-\n- - If :const:`False` (default), inputs will not be coerced to UTC.\n- Timezone-naive inputs will remain naive, while timezone-aware ones\n- will keep their time offsets. Limitations exist for mixed\n- offsets (typically, daylight savings), see :ref:`Examples\n- <to_datetime_tz_examples>` section for details.\n-\n- See also: pandas general documentation about `timezone conversion and\n- localization\n- <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html\n- #time-zone-handling>`_.\n-\n- format : str, default None\n- The strftime to parse time, e.g. :const:`\"%d/%m/%Y\"`. Note that\n- :const:`\"%f\"` will parse all the way up to nanoseconds. See\n- `strftime documentation\n- <https://docs.python.org/3/library/datetime.html\n- #strftime-and-strptime-behavior>`_ for more information on choices.\n- exact : bool, default True\n- Control how `format` is used:\n-\n- - If :const:`True`, require an exact `format` match.\n- - If :const:`False`, allow the `format` to match anywhere in the target\n- string.\n-\n- unit : str, default 'ns'\n- The unit of the arg (D,s,ms,us,ns) denote the unit, which is an\n- integer or float number. This will be based off the origin.\n- Example, with ``unit='ms'`` and ``origin='unix'``, this would calculate\n- the number of milliseconds to the unix epoch start.\n- infer_datetime_format : bool, default False\n- If :const:`True` and no `format` is given, attempt to infer the format\n- of the datetime strings based on the first non-NaN element,\n- and if it can be inferred, switch to a faster method of parsing them.\n- In some cases this can increase the parsing speed by ~5-10x.\n- origin : scalar, default 'unix'\n- Define the reference date. The numeric values would be parsed as number\n- of units (defined by `unit`) since this reference date.\n-\n- - If :const:`'unix'` (or POSIX) time; origin is set to 1970-01-01.\n- - If :const:`'julian'`, unit must be :const:`'D'`, and origin is set to\n- beginning of Julian Calendar. Julian day number :const:`0` is assigned\n- to the day starting at noon on January 1, 4713 BC.\n- - If Timestamp convertible, origin is set to Timestamp identified by\n- origin.\n- cache : bool, default True\n- If :const:`True`, use a cache of unique, converted dates to apply the\n- datetime conversion. May produce significant speed-up when parsing\n- duplicate date strings, especially ones with timezone offsets. The cache\n- is only used when there are at least 50 values. The presence of\n- out-of-bounds values will render the cache unusable and may slow down\n- parsing.\n-\n- .. versionchanged:: 0.25.0\n- changed default value from :const:`False` to :const:`True`.\n-\n- Returns\n- -------\n- datetime\n- If parsing succeeded.\n- Return type depends on input (types in parenthesis correspond to\n- fallback in case of unsuccessful timezone or out-of-range timestamp\n- parsing):\n-\n- - scalar: :class:`Timestamp` (or :class:`datetime.datetime`)\n- - array-like: :class:`DatetimeIndex` (or :class:`Series` with\n- :class:`object` dtype containing :class:`datetime.datetime`)\n- - Series: :class:`Series` of :class:`datetime64` dtype (or\n- :class:`Series` of :class:`object` dtype containing\n- :class:`datetime.datetime`)\n- - DataFrame: :class:`Series` of :class:`datetime64` dtype (or\n- :class:`Series` of :class:`object` dtype containing\n- :class:`datetime.datetime`)\n-\n- Raises\n- ------\n- ParserError\n- When parsing a date from string fails.\n- ValueError\n- When another datetime conversion error happens. For example when one\n- of 'year', 'month', day' columns is missing in a :class:`DataFrame`, or\n- when a Timezone-aware :class:`datetime.datetime` is found in an array-like\n- of mixed time offsets, and ``utc=False``.\n-\n- See Also\n- --------\n- DataFrame.astype : Cast argument to a specified dtype.\n- to_timedelta : Convert argument to timedelta.\n- convert_dtypes : Convert dtypes.\n-\n- Notes\n- -----\n-\n- Many input types are supported, and lead to different output types:\n-\n- - **scalars** can be int, float, str, datetime object (from stdlib :mod:`datetime`\n- module or :mod:`numpy`). They are converted to :class:`Timestamp` when\n- possible, otherwise they are converted to :class:`datetime.datetime`.\n- None/NaN/null scalars are converted to :const:`NaT`.\n-\n- - **array-like** can contain int, float, str, datetime objects. They are\n- converted to :class:`DatetimeIndex` when possible, otherwise they are\n- converted to :class:`Index` with :class:`object` dtype, containing\n- :class:`datetime.datetime`. None/NaN/null entries are converted to\n- :const:`NaT` in both cases.\n-\n- - **Series** are converted to :class:`Series` with :class:`datetime64`\n- dtype when possible, otherwise they are converted to :class:`Series` with\n- :class:`object` dtype, containing :class:`datetime.datetime`. None/NaN/null\n- entries are converted to :const:`NaT` in both cases.\n-\n- - **DataFrame/dict-like** are converted to :class:`Series` with\n- :class:`datetime64` dtype. For each row a datetime is created from assembling\n- the various dataframe columns. Column keys can be common abbreviations\n- like [‘year’, ‘month’, ‘day’, ‘minute’, ‘second’, ‘ms’, ‘us’, ‘ns’]) or\n- plurals of the same.\n-\n- The following causes are responsible for :class:`datetime.datetime` objects\n- being returned (possibly inside an :class:`Index` or a :class:`Series` with\n- :class:`object` dtype) instead of a proper pandas designated type\n- (:class:`Timestamp`, :class:`DatetimeIndex` or :class:`Series`\n- with :class:`datetime64` dtype):\n-\n- - when any input element is before :const:`Timestamp.min` or after\n- :const:`Timestamp.max`, see `timestamp limitations\n- <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html\n- #timeseries-timestamp-limits>`_.\n-\n- - when ``utc=False`` (default) and the input is an array-like or\n- :class:`Series` containing mixed naive/aware datetime, or aware with mixed\n- time offsets. Note that this happens in the (quite frequent) situation when\n- the timezone has a daylight savings policy. In that case you may wish to\n- use ``utc=True``.\n-\n- Examples\n- --------\n-\n- **Handling various input formats**\n-\n- Assembling a datetime from multiple columns of a :class:`DataFrame`. The keys\n- can be common abbreviations like ['year', 'month', 'day', 'minute', 'second',\n- 'ms', 'us', 'ns']) or plurals of the same\n-\n- >>> df = pd.DataFrame({'year': [2015, 2016],\n- ... 'month': [2, 3],\n- ... 'day': [4, 5]})\n- >>> pd.to_datetime(df)\n- 0 2015-02-04\n- 1 2016-03-05\n- dtype: datetime64[ns]\n-\n- Passing ``infer_datetime_format=True`` can often-times speedup a parsing\n- if its not an ISO8601 format exactly, but in a regular format.\n-\n- >>> s = pd.Series(['3/11/2000', '3/12/2000', '3/13/2000'] * 1000)\n- >>> s.head()\n- 0 3/11/2000\n- 1 3/12/2000\n- 2 3/13/2000\n- 3 3/11/2000\n- 4 3/12/2000\n- dtype: object\n-\n- >>> %timeit pd.to_datetime(s, infer_datetime_format=True) # doctest: +SKIP\n- 100 loops, best of 3: 10.4 ms per loop\n-\n- >>> %timeit pd.to_datetime(s, infer_datetime_format=False) # doctest: +SKIP\n- 1 loop, best of 3: 471 ms per loop\n-\n- Using a unix epoch time\n-\n- >>> pd.to_datetime(1490195805, unit='s')\n- Timestamp('2017-03-22 15:16:45')\n- >>> pd.to_datetime(1490195805433502912, unit='ns')\n- Timestamp('2017-03-22 15:16:45.433502912')\n-\n- .. warning:: For float arg, precision rounding might happen. To prevent\n- unexpected behavior use a fixed-width exact type.\n-\n- Using a non-unix epoch origin\n-\n- >>> pd.to_datetime([1, 2, 3], unit='D',\n- ... origin=pd.Timestamp('1960-01-01'))\n- DatetimeIndex(['1960-01-02', '1960-01-03', '1960-01-04'],\n- dtype='datetime64[ns]', freq=None)\n-\n- **Non-convertible date/times**\n-\n- If a date does not meet the `timestamp limitations\n- <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html\n- #timeseries-timestamp-limits>`_, passing ``errors='ignore'``\n- will return the original input instead of raising any exception.\n-\n- Passing ``errors='coerce'`` will force an out-of-bounds date to :const:`NaT`,\n- in addition to forcing non-dates (or non-parseable dates) to :const:`NaT`.\n-\n- >>> pd.to_datetime('13000101', format='%Y%m%d', errors='ignore')\n- datetime.datetime(1300, 1, 1, 0, 0)\n- >>> pd.to_datetime('13000101', format='%Y%m%d', errors='coerce')\n- NaT\n-\n- .. _to_datetime_tz_examples:\n-\n- **Timezones and time offsets**\n-\n- The default behaviour (``utc=False``) is as follows:\n-\n- - Timezone-naive inputs are converted to timezone-naive :class:`DatetimeIndex`:\n-\n- >>> pd.to_datetime(['2018-10-26 12:00', '2018-10-26 13:00:15'])\n- DatetimeIndex(['2018-10-26 12:00:00', '2018-10-26 13:00:15'],\n- dtype='datetime64[ns]', freq=None)\n-\n- - Timezone-aware inputs *with constant time offset* are converted to\n- timezone-aware :class:`DatetimeIndex`:\n-\n- >>> pd.to_datetime(['2018-10-26 12:00 -0500', '2018-10-26 13:00 -0500'])\n- DatetimeIndex(['2018-10-26 12:00:00-05:00', '2018-10-26 13:00:00-05:00'],\n- dtype='datetime64[ns, pytz.FixedOffset(-300)]', freq=None)\n-\n- - However, timezone-aware inputs *with mixed time offsets* (for example\n- issued from a timezone with daylight savings, such as Europe/Paris)\n- are **not successfully converted** to a :class:`DatetimeIndex`. Instead a\n- simple :class:`Index` containing :class:`datetime.datetime` objects is\n- returned:\n-\n- >>> pd.to_datetime(['2020-10-25 02:00 +0200', '2020-10-25 04:00 +0100'])\n- Index([2020-10-25 02:00:00+02:00, 2020-10-25 04:00:00+01:00],\n- dtype='object')\n-\n- - A mix of timezone-aware and timezone-naive inputs is converted to\n- a timezone-aware :class:`DatetimeIndex` if the offsets of the timezone-aware\n- are constant:\n-\n- >>> from datetime import datetime\n- >>> pd.to_datetime([\"2020-01-01 01:00 -01:00\", datetime(2020, 1, 1, 3, 0)])\n- DatetimeIndex(['2020-01-01 01:00:00-01:00', '2020-01-01 02:00:00-01:00'],\n- dtype='datetime64[ns, pytz.FixedOffset(-60)]', freq=None)\n-\n- |\n-\n- Setting ``utc=True`` solves most of the above issues:\n-\n- - Timezone-naive inputs are *localized* as UTC\n-\n- >>> pd.to_datetime(['2018-10-26 12:00', '2018-10-26 13:00'], utc=True)\n- DatetimeIndex(['2018-10-26 12:00:00+00:00', '2018-10-26 13:00:00+00:00'],\n- dtype='datetime64[ns, UTC]', freq=None)\n-\n- - Timezone-aware inputs are *converted* to UTC (the output represents the\n- exact same datetime, but viewed from the UTC time offset `+00:00`).\n-\n- >>> pd.to_datetime(['2018-10-26 12:00 -0530', '2018-10-26 12:00 -0500'],\n- ... utc=True)\n- DatetimeIndex(['2018-10-26 17:30:00+00:00', '2018-10-26 17:00:00+00:00'],\n- dtype='datetime64[ns, UTC]', freq=None)\n-\n- - Inputs can contain both naive and aware, string or datetime, the above\n- rules still apply\n-\n- >>> from datetime import timezone, timedelta\n- >>> pd.to_datetime(['2018-10-26 12:00', '2018-10-26 12:00 -0530',\n- ... datetime(2020, 1, 1, 18),\n- ... datetime(2020, 1, 1, 18,\n- ... tzinfo=timezone(-timedelta(hours=1)))],\n- ... utc=True)\n- DatetimeIndex(['2018-10-26 12:00:00+00:00', '2018-10-26 17:30:00+00:00',\n- '2020-01-01 18:00:00+00:00', '2020-01-01 19:00:00+00:00'],\n- dtype='datetime64[ns, UTC]', freq=None)\n- \"\"\"\n- if arg is None:\n- return None\n-\n- if origin != \"unix\":\n- arg = _adjust_to_origin(arg, origin, unit)\n-\n- tz = \"utc\" if utc else None\n- convert_listlike = partial(\n- _convert_listlike_datetimes,\n- tz=tz,\n- unit=unit,\n- dayfirst=dayfirst,\n- yearfirst=yearfirst,\n- errors=errors,\n- exact=exact,\n- infer_datetime_format=infer_datetime_format,\n- )\n-\n- result: Timestamp | NaTType | Series | Index\n-\n- if isinstance(arg, Timestamp):\n- result = arg\n- if tz is not None:\n- if arg.tz is not None:\n- result = arg.tz_convert(tz)\n- else:\n- result = arg.tz_localize(tz)\n- elif isinstance(arg, ABCSeries):\n- cache_array = _maybe_cache(arg, format, cache, convert_listlike)\n- if not cache_array.empty:\n- result = arg.map(cache_array)\n- else:\n- values = convert_listlike(arg._values, format)\n- result = arg._constructor(values, index=arg.index, name=arg.name)\n- elif isinstance(arg, (ABCDataFrame, abc.MutableMapping)):\n- result = _assemble_from_unit_mappings(arg, errors, tz)\n- elif isinstance(arg, Index):\n- cache_array = _maybe_cache(arg, format, cache, convert_listlike)\n- if not cache_array.empty:\n- result = _convert_and_box_cache(arg, cache_array, name=arg.name)\n- else:\n- result = convert_listlike(arg, format, name=arg.name)\n- elif is_list_like(arg):\n- try:\n- # error: Argument 1 to \"_maybe_cache\" has incompatible type\n- # \"Union[float, str, datetime, List[Any], Tuple[Any, ...], ExtensionArray,\n- # ndarray[Any, Any], Series]\"; expected \"Union[List[Any], Tuple[Any, ...],\n- # Union[Union[ExtensionArray, ndarray[Any, Any]], Index, Series], Series]\"\n- argc = cast(\n- Union[list, tuple, ExtensionArray, np.ndarray, \"Series\", Index], arg\n- )\n- cache_array = _maybe_cache(argc, format, cache, convert_listlike)\n- except OutOfBoundsDatetime:\n- # caching attempts to create a DatetimeIndex, which may raise\n- # an OOB. If that's the desired behavior, then just reraise...\n- if errors == \"raise\":\n- raise\n- # ... otherwise, continue without the cache.\n- from pandas import Series\n-\n- cache_array = Series([], dtype=object) # just an empty array\n- if not cache_array.empty:\n- result = _convert_and_box_cache(argc, cache_array)\n- else:\n- result = convert_listlike(argc, format)\n- else:\n- result = convert_listlike(np.array([arg]), format)[0]\n- if isinstance(arg, bool) and isinstance(result, np.bool_):\n- result = bool(result) # TODO: avoid this kludge.\n-\n- # error: Incompatible return value type (got \"Union[Timestamp, NaTType,\n- # Series, Index]\", expected \"Union[DatetimeIndex, Series, float, str,\n- # NaTType, None]\")\n- return result # type: ignore[return-value]\n-\n-\n-# mappings for assembling units\n-_unit_map = {\n- \"year\": \"year\",\n- \"years\": \"year\",\n- \"month\": \"month\",\n- \"months\": \"month\",\n- \"day\": \"day\",\n- \"days\": \"day\",\n- \"hour\": \"h\",\n- \"hours\": \"h\",\n- \"minute\": \"m\",\n- \"minutes\": \"m\",\n- \"second\": \"s\",\n- \"seconds\": \"s\",\n- \"ms\": \"ms\",\n- \"millisecond\": \"ms\",\n- \"milliseconds\": \"ms\",\n- \"us\": \"us\",\n- \"microsecond\": \"us\",\n- \"microseconds\": \"us\",\n- \"ns\": \"ns\",\n- \"nanosecond\": \"ns\",\n- \"nanoseconds\": \"ns\",\n-}\n-\n-\n-def _assemble_from_unit_mappings(arg, errors: DateTimeErrorChoices, tz):\n- \"\"\"\n- assemble the unit specified fields from the arg (DataFrame)\n- Return a Series for actual parsing\n-\n- Parameters\n- ----------\n- arg : DataFrame\n- errors : {'ignore', 'raise', 'coerce'}, default 'raise'\n-\n- - If :const:`'raise'`, then invalid parsing will raise an exception\n- - If :const:`'coerce'`, then invalid parsing will be set as :const:`NaT`\n- - If :const:`'ignore'`, then invalid parsing will return the input\n- tz : None or 'utc'\n-\n- Returns\n- -------\n- Series\n- \"\"\"\n- from pandas import (\n- DataFrame,\n- to_numeric,\n- to_timedelta,\n- )\n-\n- arg = DataFrame(arg)\n- if not arg.columns.is_unique:\n- raise ValueError(\"cannot assemble with duplicate keys\")\n-\n- # replace passed unit with _unit_map\n- def f(value):\n- if value in _unit_map:\n- return _unit_map[value]\n-\n- # m is case significant\n- if value.lower() in _unit_map:\n- return _unit_map[value.lower()]\n-\n- return value\n-\n- unit = {k: f(k) for k in arg.keys()}\n- unit_rev = {v: k for k, v in unit.items()}\n-\n- # we require at least Ymd\n- required = [\"year\", \"month\", \"day\"]\n- req = sorted(set(required) - set(unit_rev.keys()))\n- if len(req):\n- _required = \",\".join(req)\n- raise ValueError(\n- \"to assemble mappings requires at least that \"\n- f\"[year, month, day] be specified: [{_required}] is missing\"\n- )\n-\n- # keys we don't recognize\n- excess = sorted(set(unit_rev.keys()) - set(_unit_map.values()))\n- if len(excess):\n- _excess = \",\".join(excess)\n- raise ValueError(\n- f\"extra keys have been passed to the datetime assemblage: [{_excess}]\"\n- )\n-\n- def coerce(values):\n- # we allow coercion to if errors allows\n- values = to_numeric(values, errors=errors)\n-\n- # prevent overflow in case of int8 or int16\n- if is_integer_dtype(values):\n- values = values.astype(\"int64\", copy=False)\n- return values\n-\n- values = (\n- coerce(arg[unit_rev[\"year\"]]) * 10000\n- + coerce(arg[unit_rev[\"month\"]]) * 100\n- + coerce(arg[unit_rev[\"day\"]])\n- )\n- try:\n- values = to_datetime(values, format=\"%Y%m%d\", errors=errors, utc=tz)\n- except (TypeError, ValueError) as err:\n- raise ValueError(f\"cannot assemble the datetimes: {err}\") from err\n-\n- units: list[UnitChoices] = [\"h\", \"m\", \"s\", \"ms\", \"us\", \"ns\"]\n- for u in units:\n- value = unit_rev.get(u)\n- if value is not None and value in arg:\n- try:\n- values += to_timedelta(coerce(arg[value]), unit=u, errors=errors)\n- except (TypeError, ValueError) as err:\n- raise ValueError(\n- f\"cannot assemble the datetimes [{value}]: {err}\"\n- ) from err\n- return values\n-\n-\n-def _attempt_YYYYMMDD(arg: npt.NDArray[np.object_], errors: str) -> np.ndarray | None:\n- \"\"\"\n- try to parse the YYYYMMDD/%Y%m%d format, try to deal with NaT-like,\n- arg is a passed in as an object dtype, but could really be ints/strings\n- with nan-like/or floats (e.g. with nan)\n-\n- Parameters\n- ----------\n- arg : np.ndarray[object]\n- errors : {'raise','ignore','coerce'}\n- \"\"\"\n-\n- def calc(carg):\n- # calculate the actual result\n- carg = carg.astype(object, copy=False)\n- parsed = parsing.try_parse_year_month_day(\n- carg / 10000, carg / 100 % 100, carg % 100\n- )\n- return tslib.array_to_datetime(parsed, errors=errors)[0]\n-\n- def calc_with_mask(carg, mask):\n- result = np.empty(carg.shape, dtype=\"M8[ns]\")\n- iresult = result.view(\"i8\")\n- iresult[~mask] = iNaT\n-\n- masked_result = calc(carg[mask].astype(np.float64).astype(np.int64))\n- result[mask] = masked_result.astype(\"M8[ns]\")\n- return result\n-\n- # try intlike / strings that are ints\n- try:\n- return calc(arg.astype(np.int64))\n- except (ValueError, OverflowError, TypeError):\n- pass\n-\n- # a float with actual np.nan\n- try:\n- carg = arg.astype(np.float64)\n- return calc_with_mask(carg, notna(carg))\n- except (ValueError, OverflowError, TypeError):\n- pass\n-\n- # string with NaN-like\n- try:\n- # error: Argument 2 to \"isin\" has incompatible type \"List[Any]\"; expected\n- # \"Union[Union[ExtensionArray, ndarray], Index, Series]\"\n- mask = ~algorithms.isin(arg, list(nat_strings)) # type: ignore[arg-type]\n- return calc_with_mask(arg, mask)\n- except (ValueError, OverflowError, TypeError):\n- pass\n-\n- return None\n-\n-\n-def to_time(arg, format=None, infer_time_format=False, errors=\"raise\"):\n- # GH#34145\n- warnings.warn(\n- \"`to_time` has been moved, should be imported from pandas.core.tools.times. \"\n- \"This alias will be removed in a future version.\",\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n- from pandas.core.tools.times import to_time\n-\n- return to_time(arg, format, infer_time_format, errors)\n+from pandas._core.tools.datetimes import *\ndiff --git a/pandas/core/tools/numeric.py b/pandas/core/tools/numeric.py\nindex ef7f4bc92e25b..af82cf6b94f69 100644\n--- a/pandas/core/tools/numeric.py\n+++ b/pandas/core/tools/numeric.py\n@@ -1,244 +1 @@\n-from __future__ import annotations\n-\n-import numpy as np\n-\n-from pandas._libs import lib\n-from pandas._typing import npt\n-\n-from pandas.core.dtypes.cast import maybe_downcast_numeric\n-from pandas.core.dtypes.common import (\n- ensure_object,\n- is_datetime_or_timedelta_dtype,\n- is_decimal,\n- is_integer_dtype,\n- is_number,\n- is_numeric_dtype,\n- is_scalar,\n- needs_i8_conversion,\n-)\n-from pandas.core.dtypes.generic import (\n- ABCIndex,\n- ABCSeries,\n-)\n-\n-import pandas as pd\n-from pandas.core.arrays.numeric import NumericArray\n-\n-\n-def to_numeric(arg, errors=\"raise\", downcast=None):\n- \"\"\"\n- Convert argument to a numeric type.\n-\n- The default return dtype is `float64` or `int64`\n- depending on the data supplied. Use the `downcast` parameter\n- to obtain other dtypes.\n-\n- Please note that precision loss may occur if really large numbers\n- are passed in. Due to the internal limitations of `ndarray`, if\n- numbers smaller than `-9223372036854775808` (np.iinfo(np.int64).min)\n- or larger than `18446744073709551615` (np.iinfo(np.uint64).max) are\n- passed in, it is very likely they will be converted to float so that\n- they can stored in an `ndarray`. These warnings apply similarly to\n- `Series` since it internally leverages `ndarray`.\n-\n- Parameters\n- ----------\n- arg : scalar, list, tuple, 1-d array, or Series\n- Argument to be converted.\n- errors : {'ignore', 'raise', 'coerce'}, default 'raise'\n- - If 'raise', then invalid parsing will raise an exception.\n- - If 'coerce', then invalid parsing will be set as NaN.\n- - If 'ignore', then invalid parsing will return the input.\n- downcast : str, default None\n- Can be 'integer', 'signed', 'unsigned', or 'float'.\n- If not None, and if the data has been successfully cast to a\n- numerical dtype (or if the data was numeric to begin with),\n- downcast that resulting data to the smallest numerical dtype\n- possible according to the following rules:\n-\n- - 'integer' or 'signed': smallest signed int dtype (min.: np.int8)\n- - 'unsigned': smallest unsigned int dtype (min.: np.uint8)\n- - 'float': smallest float dtype (min.: np.float32)\n-\n- As this behaviour is separate from the core conversion to\n- numeric values, any errors raised during the downcasting\n- will be surfaced regardless of the value of the 'errors' input.\n-\n- In addition, downcasting will only occur if the size\n- of the resulting data's dtype is strictly larger than\n- the dtype it is to be cast to, so if none of the dtypes\n- checked satisfy that specification, no downcasting will be\n- performed on the data.\n-\n- Returns\n- -------\n- ret\n- Numeric if parsing succeeded.\n- Return type depends on input. Series if Series, otherwise ndarray.\n-\n- See Also\n- --------\n- DataFrame.astype : Cast argument to a specified dtype.\n- to_datetime : Convert argument to datetime.\n- to_timedelta : Convert argument to timedelta.\n- numpy.ndarray.astype : Cast a numpy array to a specified type.\n- DataFrame.convert_dtypes : Convert dtypes.\n-\n- Examples\n- --------\n- Take separate series and convert to numeric, coercing when told to\n-\n- >>> s = pd.Series(['1.0', '2', -3])\n- >>> pd.to_numeric(s)\n- 0 1.0\n- 1 2.0\n- 2 -3.0\n- dtype: float64\n- >>> pd.to_numeric(s, downcast='float')\n- 0 1.0\n- 1 2.0\n- 2 -3.0\n- dtype: float32\n- >>> pd.to_numeric(s, downcast='signed')\n- 0 1\n- 1 2\n- 2 -3\n- dtype: int8\n- >>> s = pd.Series(['apple', '1.0', '2', -3])\n- >>> pd.to_numeric(s, errors='ignore')\n- 0 apple\n- 1 1.0\n- 2 2\n- 3 -3\n- dtype: object\n- >>> pd.to_numeric(s, errors='coerce')\n- 0 NaN\n- 1 1.0\n- 2 2.0\n- 3 -3.0\n- dtype: float64\n-\n- Downcasting of nullable integer and floating dtypes is supported:\n-\n- >>> s = pd.Series([1, 2, 3], dtype=\"Int64\")\n- >>> pd.to_numeric(s, downcast=\"integer\")\n- 0 1\n- 1 2\n- 2 3\n- dtype: Int8\n- >>> s = pd.Series([1.0, 2.1, 3.0], dtype=\"Float64\")\n- >>> pd.to_numeric(s, downcast=\"float\")\n- 0 1.0\n- 1 2.1\n- 2 3.0\n- dtype: Float32\n- \"\"\"\n- if downcast not in (None, \"integer\", \"signed\", \"unsigned\", \"float\"):\n- raise ValueError(\"invalid downcasting method provided\")\n-\n- if errors not in (\"ignore\", \"raise\", \"coerce\"):\n- raise ValueError(\"invalid error value specified\")\n-\n- is_series = False\n- is_index = False\n- is_scalars = False\n-\n- if isinstance(arg, ABCSeries):\n- is_series = True\n- values = arg.values\n- elif isinstance(arg, ABCIndex):\n- is_index = True\n- if needs_i8_conversion(arg.dtype):\n- values = arg.asi8\n- else:\n- values = arg.values\n- elif isinstance(arg, (list, tuple)):\n- values = np.array(arg, dtype=\"O\")\n- elif is_scalar(arg):\n- if is_decimal(arg):\n- return float(arg)\n- if is_number(arg):\n- return arg\n- is_scalars = True\n- values = np.array([arg], dtype=\"O\")\n- elif getattr(arg, \"ndim\", 1) > 1:\n- raise TypeError(\"arg must be a list, tuple, 1-d array, or Series\")\n- else:\n- values = arg\n-\n- # GH33013: for IntegerArray & FloatingArray extract non-null values for casting\n- # save mask to reconstruct the full array after casting\n- mask: npt.NDArray[np.bool_] | None = None\n- if isinstance(values, NumericArray):\n- mask = values._mask\n- values = values._data[~mask]\n-\n- values_dtype = getattr(values, \"dtype\", None)\n- if is_numeric_dtype(values_dtype):\n- pass\n- elif is_datetime_or_timedelta_dtype(values_dtype):\n- values = values.view(np.int64)\n- else:\n- values = ensure_object(values)\n- coerce_numeric = errors not in (\"ignore\", \"raise\")\n- try:\n- values, _ = lib.maybe_convert_numeric(\n- values, set(), coerce_numeric=coerce_numeric\n- )\n- except (ValueError, TypeError):\n- if errors == \"raise\":\n- raise\n-\n- # attempt downcast only if the data has been successfully converted\n- # to a numerical dtype and if a downcast method has been specified\n- if downcast is not None and is_numeric_dtype(values.dtype):\n- typecodes: str | None = None\n-\n- if downcast in (\"integer\", \"signed\"):\n- typecodes = np.typecodes[\"Integer\"]\n- elif downcast == \"unsigned\" and (not len(values) or np.min(values) >= 0):\n- typecodes = np.typecodes[\"UnsignedInteger\"]\n- elif downcast == \"float\":\n- typecodes = np.typecodes[\"Float\"]\n-\n- # pandas support goes only to np.float32,\n- # as float dtypes smaller than that are\n- # extremely rare and not well supported\n- float_32_char = np.dtype(np.float32).char\n- float_32_ind = typecodes.index(float_32_char)\n- typecodes = typecodes[float_32_ind:]\n-\n- if typecodes is not None:\n- # from smallest to largest\n- for typecode in typecodes:\n- dtype = np.dtype(typecode)\n- if dtype.itemsize <= values.dtype.itemsize:\n- values = maybe_downcast_numeric(values, dtype)\n-\n- # successful conversion\n- if values.dtype == dtype:\n- break\n-\n- # GH33013: for IntegerArray & FloatingArray need to reconstruct masked array\n- if mask is not None:\n- data = np.zeros(mask.shape, dtype=values.dtype)\n- data[~mask] = values\n-\n- from pandas.core.arrays import (\n- FloatingArray,\n- IntegerArray,\n- )\n-\n- klass = IntegerArray if is_integer_dtype(data.dtype) else FloatingArray\n- values = klass(data, mask.copy())\n-\n- if is_series:\n- return arg._constructor(values, index=arg.index, name=arg.name)\n- elif is_index:\n- # because we want to coerce to numeric if possible,\n- # do not use _shallow_copy\n- return pd.Index(values, name=arg.name)\n- elif is_scalars:\n- return values[0]\n- else:\n- return values\n+from pandas._core.tools.numeric import *\ndiff --git a/pandas/core/tools/timedeltas.py b/pandas/core/tools/timedeltas.py\nindex 720d02f0cf59e..d500eaaa5cc5b 100644\n--- a/pandas/core/tools/timedeltas.py\n+++ b/pandas/core/tools/timedeltas.py\n@@ -1,259 +1 @@\n-\"\"\"\n-timedelta support tools\n-\"\"\"\n-from __future__ import annotations\n-\n-from datetime import timedelta\n-from typing import (\n- TYPE_CHECKING,\n- overload,\n-)\n-\n-import numpy as np\n-\n-from pandas._libs import lib\n-from pandas._libs.tslibs import (\n- NaT,\n- NaTType,\n-)\n-from pandas._libs.tslibs.timedeltas import (\n- Timedelta,\n- parse_timedelta_unit,\n-)\n-\n-from pandas.core.dtypes.common import is_list_like\n-from pandas.core.dtypes.generic import (\n- ABCIndex,\n- ABCSeries,\n-)\n-\n-from pandas.core.arrays.timedeltas import sequence_to_td64ns\n-\n-if TYPE_CHECKING:\n- from pandas._libs.tslibs.timedeltas import UnitChoices\n- from pandas._typing import (\n- ArrayLike,\n- DateTimeErrorChoices,\n- )\n-\n- from pandas import (\n- Index,\n- Series,\n- TimedeltaIndex,\n- )\n-\n-\n-@overload\n-def to_timedelta(\n- arg: str | int | float | timedelta,\n- unit: UnitChoices | None = ...,\n- errors: DateTimeErrorChoices = ...,\n-) -> Timedelta:\n- ...\n-\n-\n-@overload\n-def to_timedelta(\n- arg: Series,\n- unit: UnitChoices | None = ...,\n- errors: DateTimeErrorChoices = ...,\n-) -> Series:\n- ...\n-\n-\n-@overload\n-def to_timedelta(\n- arg: list | tuple | range | ArrayLike | Index,\n- unit: UnitChoices | None = ...,\n- errors: DateTimeErrorChoices = ...,\n-) -> TimedeltaIndex:\n- ...\n-\n-\n-def to_timedelta(\n- arg: str\n- | int\n- | float\n- | timedelta\n- | list\n- | tuple\n- | range\n- | ArrayLike\n- | Index\n- | Series,\n- unit: UnitChoices | None = None,\n- errors: DateTimeErrorChoices = \"raise\",\n-) -> Timedelta | TimedeltaIndex | Series:\n- \"\"\"\n- Convert argument to timedelta.\n-\n- Timedeltas are absolute differences in times, expressed in difference\n- units (e.g. days, hours, minutes, seconds). This method converts\n- an argument from a recognized timedelta format / value into\n- a Timedelta type.\n-\n- Parameters\n- ----------\n- arg : str, timedelta, list-like or Series\n- The data to be converted to timedelta.\n-\n- .. deprecated:: 1.2\n- Strings with units 'M', 'Y' and 'y' do not represent\n- unambiguous timedelta values and will be removed in a future version\n-\n- unit : str, optional\n- Denotes the unit of the arg for numeric `arg`. Defaults to ``\"ns\"``.\n-\n- Possible values:\n-\n- * 'W'\n- * 'D' / 'days' / 'day'\n- * 'hours' / 'hour' / 'hr' / 'h'\n- * 'm' / 'minute' / 'min' / 'minutes' / 'T'\n- * 'S' / 'seconds' / 'sec' / 'second'\n- * 'ms' / 'milliseconds' / 'millisecond' / 'milli' / 'millis' / 'L'\n- * 'us' / 'microseconds' / 'microsecond' / 'micro' / 'micros' / 'U'\n- * 'ns' / 'nanoseconds' / 'nano' / 'nanos' / 'nanosecond' / 'N'\n-\n- .. versionchanged:: 1.1.0\n-\n- Must not be specified when `arg` context strings and\n- ``errors=\"raise\"``.\n-\n- errors : {'ignore', 'raise', 'coerce'}, default 'raise'\n- - If 'raise', then invalid parsing will raise an exception.\n- - If 'coerce', then invalid parsing will be set as NaT.\n- - If 'ignore', then invalid parsing will return the input.\n-\n- Returns\n- -------\n- timedelta\n- If parsing succeeded.\n- Return type depends on input:\n-\n- - list-like: TimedeltaIndex of timedelta64 dtype\n- - Series: Series of timedelta64 dtype\n- - scalar: Timedelta\n-\n- See Also\n- --------\n- DataFrame.astype : Cast argument to a specified dtype.\n- to_datetime : Convert argument to datetime.\n- convert_dtypes : Convert dtypes.\n-\n- Notes\n- -----\n- If the precision is higher than nanoseconds, the precision of the duration is\n- truncated to nanoseconds for string inputs.\n-\n- Examples\n- --------\n- Parsing a single string to a Timedelta:\n-\n- >>> pd.to_timedelta('1 days 06:05:01.00003')\n- Timedelta('1 days 06:05:01.000030')\n- >>> pd.to_timedelta('15.5us')\n- Timedelta('0 days 00:00:00.000015500')\n-\n- Parsing a list or array of strings:\n-\n- >>> pd.to_timedelta(['1 days 06:05:01.00003', '15.5us', 'nan'])\n- TimedeltaIndex(['1 days 06:05:01.000030', '0 days 00:00:00.000015500', NaT],\n- dtype='timedelta64[ns]', freq=None)\n-\n- Converting numbers by specifying the `unit` keyword argument:\n-\n- >>> pd.to_timedelta(np.arange(5), unit='s')\n- TimedeltaIndex(['0 days 00:00:00', '0 days 00:00:01', '0 days 00:00:02',\n- '0 days 00:00:03', '0 days 00:00:04'],\n- dtype='timedelta64[ns]', freq=None)\n- >>> pd.to_timedelta(np.arange(5), unit='d')\n- TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'],\n- dtype='timedelta64[ns]', freq=None)\n- \"\"\"\n- if unit is not None:\n- unit = parse_timedelta_unit(unit)\n-\n- if errors not in (\"ignore\", \"raise\", \"coerce\"):\n- raise ValueError(\"errors must be one of 'ignore', 'raise', or 'coerce'.\")\n-\n- if unit in {\"Y\", \"y\", \"M\"}:\n- raise ValueError(\n- \"Units 'M', 'Y', and 'y' are no longer supported, as they do not \"\n- \"represent unambiguous timedelta values durations.\"\n- )\n-\n- if arg is None:\n- return arg\n- elif isinstance(arg, ABCSeries):\n- values = _convert_listlike(arg._values, unit=unit, errors=errors)\n- return arg._constructor(values, index=arg.index, name=arg.name)\n- elif isinstance(arg, ABCIndex):\n- return _convert_listlike(arg, unit=unit, errors=errors, name=arg.name)\n- elif isinstance(arg, np.ndarray) and arg.ndim == 0:\n- # extract array scalar and process below\n- # error: Incompatible types in assignment (expression has type \"object\",\n- # variable has type \"Union[str, int, float, timedelta, List[Any],\n- # Tuple[Any, ...], Union[Union[ExtensionArray, ndarray[Any, Any]], Index,\n- # Series]]\") [assignment]\n- arg = lib.item_from_zerodim(arg) # type: ignore[assignment]\n- elif is_list_like(arg) and getattr(arg, \"ndim\", 1) == 1:\n- return _convert_listlike(arg, unit=unit, errors=errors)\n- elif getattr(arg, \"ndim\", 1) > 1:\n- raise TypeError(\n- \"arg must be a string, timedelta, list, tuple, 1-d array, or Series\"\n- )\n-\n- if isinstance(arg, str) and unit is not None:\n- raise ValueError(\"unit must not be specified if the input is/contains a str\")\n-\n- # ...so it must be a scalar value. Return scalar.\n- return _coerce_scalar_to_timedelta_type(arg, unit=unit, errors=errors)\n-\n-\n-def _coerce_scalar_to_timedelta_type(r, unit=\"ns\", errors=\"raise\"):\n- \"\"\"Convert string 'r' to a timedelta object.\"\"\"\n- result: Timedelta | NaTType\n-\n- try:\n- result = Timedelta(r, unit)\n- except ValueError:\n- if errors == \"raise\":\n- raise\n- elif errors == \"ignore\":\n- return r\n-\n- # coerce\n- result = NaT\n-\n- return result\n-\n-\n-def _convert_listlike(arg, unit=None, errors=\"raise\", name=None):\n- \"\"\"Convert a list of objects to a timedelta index object.\"\"\"\n- if isinstance(arg, (list, tuple)) or not hasattr(arg, \"dtype\"):\n- # This is needed only to ensure that in the case where we end up\n- # returning arg (errors == \"ignore\"), and where the input is a\n- # generator, we return a useful list-like instead of a\n- # used-up generator\n- arg = np.array(list(arg), dtype=object)\n-\n- try:\n- td64arr = sequence_to_td64ns(arg, unit=unit, errors=errors, copy=False)[0]\n- except ValueError:\n- if errors == \"ignore\":\n- return arg\n- else:\n- # This else-block accounts for the cases when errors='raise'\n- # and errors='coerce'. If errors == 'raise', these errors\n- # should be raised. If errors == 'coerce', we shouldn't\n- # expect any errors to be raised, since all parsing errors\n- # cause coercion to pd.NaT. However, if an error / bug is\n- # introduced that causes an Exception to be raised, we would\n- # like to surface it.\n- raise\n-\n- from pandas import TimedeltaIndex\n-\n- value = TimedeltaIndex(td64arr, unit=\"ns\", name=name)\n- return value\n+from pandas._core.tools.timedeltas import *\ndiff --git a/pandas/core/tools/times.py b/pandas/core/tools/times.py\nindex 030cee3f678f4..ede8ae7fedf50 100644\n--- a/pandas/core/tools/times.py\n+++ b/pandas/core/tools/times.py\n@@ -1,146 +1 @@\n-from __future__ import annotations\n-\n-from datetime import (\n- datetime,\n- time,\n-)\n-\n-import numpy as np\n-\n-from pandas._libs.lib import is_list_like\n-\n-from pandas.core.dtypes.generic import (\n- ABCIndex,\n- ABCSeries,\n-)\n-from pandas.core.dtypes.missing import notna\n-\n-\n-def to_time(arg, format=None, infer_time_format=False, errors=\"raise\"):\n- \"\"\"\n- Parse time strings to time objects using fixed strptime formats (\"%H:%M\",\n- \"%H%M\", \"%I:%M%p\", \"%I%M%p\", \"%H:%M:%S\", \"%H%M%S\", \"%I:%M:%S%p\",\n- \"%I%M%S%p\")\n-\n- Use infer_time_format if all the strings are in the same format to speed\n- up conversion.\n-\n- Parameters\n- ----------\n- arg : string in time format, datetime.time, list, tuple, 1-d array, Series\n- format : str, default None\n- Format used to convert arg into a time object. If None, fixed formats\n- are used.\n- infer_time_format: bool, default False\n- Infer the time format based on the first non-NaN element. If all\n- strings are in the same format, this will speed up conversion.\n- errors : {'ignore', 'raise', 'coerce'}, default 'raise'\n- - If 'raise', then invalid parsing will raise an exception\n- - If 'coerce', then invalid parsing will be set as None\n- - If 'ignore', then invalid parsing will return the input\n-\n- Returns\n- -------\n- datetime.time\n- \"\"\"\n-\n- def _convert_listlike(arg, format):\n-\n- if isinstance(arg, (list, tuple)):\n- arg = np.array(arg, dtype=\"O\")\n-\n- elif getattr(arg, \"ndim\", 1) > 1:\n- raise TypeError(\n- \"arg must be a string, datetime, list, tuple, 1-d array, or Series\"\n- )\n-\n- arg = np.asarray(arg, dtype=\"O\")\n-\n- if infer_time_format and format is None:\n- format = _guess_time_format_for_array(arg)\n-\n- times: list[time | None] = []\n- if format is not None:\n- for element in arg:\n- try:\n- times.append(datetime.strptime(element, format).time())\n- except (ValueError, TypeError) as err:\n- if errors == \"raise\":\n- msg = (\n- f\"Cannot convert {element} to a time with given \"\n- f\"format {format}\"\n- )\n- raise ValueError(msg) from err\n- elif errors == \"ignore\":\n- return arg\n- else:\n- times.append(None)\n- else:\n- formats = _time_formats[:]\n- format_found = False\n- for element in arg:\n- time_object = None\n- for time_format in formats:\n- try:\n- time_object = datetime.strptime(element, time_format).time()\n- if not format_found:\n- # Put the found format in front\n- fmt = formats.pop(formats.index(time_format))\n- formats.insert(0, fmt)\n- format_found = True\n- break\n- except (ValueError, TypeError):\n- continue\n-\n- if time_object is not None:\n- times.append(time_object)\n- elif errors == \"raise\":\n- raise ValueError(f\"Cannot convert arg {arg} to a time\")\n- elif errors == \"ignore\":\n- return arg\n- else:\n- times.append(None)\n-\n- return times\n-\n- if arg is None:\n- return arg\n- elif isinstance(arg, time):\n- return arg\n- elif isinstance(arg, ABCSeries):\n- values = _convert_listlike(arg._values, format)\n- return arg._constructor(values, index=arg.index, name=arg.name)\n- elif isinstance(arg, ABCIndex):\n- return _convert_listlike(arg, format)\n- elif is_list_like(arg):\n- return _convert_listlike(arg, format)\n-\n- return _convert_listlike(np.array([arg]), format)[0]\n-\n-\n-# Fixed time formats for time parsing\n-_time_formats = [\n- \"%H:%M\",\n- \"%H%M\",\n- \"%I:%M%p\",\n- \"%I%M%p\",\n- \"%H:%M:%S\",\n- \"%H%M%S\",\n- \"%I:%M:%S%p\",\n- \"%I%M%S%p\",\n-]\n-\n-\n-def _guess_time_format_for_array(arr):\n- # Try to guess the format based on the first non-NaN element\n- non_nan_elements = notna(arr).nonzero()[0]\n- if len(non_nan_elements):\n- element = arr[non_nan_elements[0]]\n- for time_format in _time_formats:\n- try:\n- datetime.strptime(element, time_format)\n- return time_format\n- except ValueError:\n- pass\n-\n- return None\n+from pandas._core.tools.times import *\ndiff --git a/pandas/core/util/__init__.py b/pandas/core/util/__init__.py\nindex e69de29bb2d1d..2cf15fded0b87 100644\n--- a/pandas/core/util/__init__.py\n+++ b/pandas/core/util/__init__.py\n@@ -0,0 +1 @@\n+from pandas._core.util.__init__ import *\ndiff --git a/pandas/core/util/hashing.py b/pandas/core/util/hashing.py\nindex 5a5e46e0227aa..fe5e2ff406a59 100644\n--- a/pandas/core/util/hashing.py\n+++ b/pandas/core/util/hashing.py\n@@ -1,366 +1 @@\n-\"\"\"\n-data hash pandas / numpy objects\n-\"\"\"\n-from __future__ import annotations\n-\n-import itertools\n-from typing import (\n- TYPE_CHECKING,\n- Hashable,\n- Iterable,\n- Iterator,\n- cast,\n-)\n-\n-import numpy as np\n-\n-from pandas._libs import lib\n-from pandas._libs.hashing import hash_object_array\n-from pandas._typing import (\n- ArrayLike,\n- npt,\n-)\n-\n-from pandas.core.dtypes.common import (\n- is_categorical_dtype,\n- is_list_like,\n-)\n-from pandas.core.dtypes.generic import (\n- ABCDataFrame,\n- ABCExtensionArray,\n- ABCIndex,\n- ABCMultiIndex,\n- ABCSeries,\n-)\n-\n-if TYPE_CHECKING:\n- from pandas import (\n- Categorical,\n- DataFrame,\n- Index,\n- MultiIndex,\n- Series,\n- )\n-\n-\n-# 16 byte long hashing key\n-_default_hash_key = \"0123456789123456\"\n-\n-\n-def combine_hash_arrays(\n- arrays: Iterator[np.ndarray], num_items: int\n-) -> npt.NDArray[np.uint64]:\n- \"\"\"\n- Parameters\n- ----------\n- arrays : Iterator[np.ndarray]\n- num_items : int\n-\n- Returns\n- -------\n- np.ndarray[uint64]\n-\n- Should be the same as CPython's tupleobject.c\n- \"\"\"\n- try:\n- first = next(arrays)\n- except StopIteration:\n- return np.array([], dtype=np.uint64)\n-\n- arrays = itertools.chain([first], arrays)\n-\n- mult = np.uint64(1000003)\n- out = np.zeros_like(first) + np.uint64(0x345678)\n- for i, a in enumerate(arrays):\n- inverse_i = num_items - i\n- out ^= a\n- out *= mult\n- mult += np.uint64(82520 + inverse_i + inverse_i)\n- assert i + 1 == num_items, \"Fed in wrong num_items\"\n- out += np.uint64(97531)\n- return out\n-\n-\n-def hash_pandas_object(\n- obj: Index | DataFrame | Series,\n- index: bool = True,\n- encoding: str = \"utf8\",\n- hash_key: str | None = _default_hash_key,\n- categorize: bool = True,\n-) -> Series:\n- \"\"\"\n- Return a data hash of the Index/Series/DataFrame.\n-\n- Parameters\n- ----------\n- obj : Index, Series, or DataFrame\n- index : bool, default True\n- Include the index in the hash (if Series/DataFrame).\n- encoding : str, default 'utf8'\n- Encoding for data & key when strings.\n- hash_key : str, default _default_hash_key\n- Hash_key for string key to encode.\n- categorize : bool, default True\n- Whether to first categorize object arrays before hashing. This is more\n- efficient when the array contains duplicate values.\n-\n- Returns\n- -------\n- Series of uint64, same length as the object\n- \"\"\"\n- from pandas import Series\n-\n- if hash_key is None:\n- hash_key = _default_hash_key\n-\n- if isinstance(obj, ABCMultiIndex):\n- return Series(hash_tuples(obj, encoding, hash_key), dtype=\"uint64\", copy=False)\n-\n- elif isinstance(obj, ABCIndex):\n- h = hash_array(obj._values, encoding, hash_key, categorize).astype(\n- \"uint64\", copy=False\n- )\n- ser = Series(h, index=obj, dtype=\"uint64\", copy=False)\n-\n- elif isinstance(obj, ABCSeries):\n- h = hash_array(obj._values, encoding, hash_key, categorize).astype(\n- \"uint64\", copy=False\n- )\n- if index:\n- index_iter = (\n- hash_pandas_object(\n- obj.index,\n- index=False,\n- encoding=encoding,\n- hash_key=hash_key,\n- categorize=categorize,\n- )._values\n- for _ in [None]\n- )\n- arrays = itertools.chain([h], index_iter)\n- h = combine_hash_arrays(arrays, 2)\n-\n- ser = Series(h, index=obj.index, dtype=\"uint64\", copy=False)\n-\n- elif isinstance(obj, ABCDataFrame):\n- hashes = (\n- hash_array(series._values, encoding, hash_key, categorize)\n- for _, series in obj.items()\n- )\n- num_items = len(obj.columns)\n- if index:\n- index_hash_generator = (\n- hash_pandas_object(\n- obj.index,\n- index=False,\n- encoding=encoding,\n- hash_key=hash_key,\n- categorize=categorize,\n- )._values\n- for _ in [None]\n- )\n- num_items += 1\n-\n- # keep `hashes` specifically a generator to keep mypy happy\n- _hashes = itertools.chain(hashes, index_hash_generator)\n- hashes = (x for x in _hashes)\n- h = combine_hash_arrays(hashes, num_items)\n-\n- ser = Series(h, index=obj.index, dtype=\"uint64\", copy=False)\n- else:\n- raise TypeError(f\"Unexpected type for hashing {type(obj)}\")\n-\n- return ser\n-\n-\n-def hash_tuples(\n- vals: MultiIndex | Iterable[tuple[Hashable, ...]],\n- encoding: str = \"utf8\",\n- hash_key: str = _default_hash_key,\n-) -> npt.NDArray[np.uint64]:\n- \"\"\"\n- Hash an MultiIndex / listlike-of-tuples efficiently.\n-\n- Parameters\n- ----------\n- vals : MultiIndex or listlike-of-tuples\n- encoding : str, default 'utf8'\n- hash_key : str, default _default_hash_key\n-\n- Returns\n- -------\n- ndarray[np.uint64] of hashed values\n- \"\"\"\n- if not is_list_like(vals):\n- raise TypeError(\"must be convertible to a list-of-tuples\")\n-\n- from pandas import (\n- Categorical,\n- MultiIndex,\n- )\n-\n- if not isinstance(vals, ABCMultiIndex):\n- mi = MultiIndex.from_tuples(vals)\n- else:\n- mi = vals\n-\n- # create a list-of-Categoricals\n- cat_vals = [\n- Categorical(mi.codes[level], mi.levels[level], ordered=False, fastpath=True)\n- for level in range(mi.nlevels)\n- ]\n-\n- # hash the list-of-ndarrays\n- hashes = (\n- _hash_categorical(cat, encoding=encoding, hash_key=hash_key) for cat in cat_vals\n- )\n- h = combine_hash_arrays(hashes, len(cat_vals))\n-\n- return h\n-\n-\n-def _hash_categorical(\n- cat: Categorical, encoding: str, hash_key: str\n-) -> npt.NDArray[np.uint64]:\n- \"\"\"\n- Hash a Categorical by hashing its categories, and then mapping the codes\n- to the hashes\n-\n- Parameters\n- ----------\n- cat : Categorical\n- encoding : str\n- hash_key : str\n-\n- Returns\n- -------\n- ndarray[np.uint64] of hashed values, same size as len(c)\n- \"\"\"\n- # Convert ExtensionArrays to ndarrays\n- values = np.asarray(cat.categories._values)\n- hashed = hash_array(values, encoding, hash_key, categorize=False)\n-\n- # we have uint64, as we don't directly support missing values\n- # we don't want to use take_nd which will coerce to float\n- # instead, directly construct the result with a\n- # max(np.uint64) as the missing value indicator\n- #\n- # TODO: GH 15362\n-\n- mask = cat.isna()\n- if len(hashed):\n- result = hashed.take(cat.codes)\n- else:\n- result = np.zeros(len(mask), dtype=\"uint64\")\n-\n- if mask.any():\n- result[mask] = lib.u8max\n-\n- return result\n-\n-\n-def hash_array(\n- vals: ArrayLike,\n- encoding: str = \"utf8\",\n- hash_key: str = _default_hash_key,\n- categorize: bool = True,\n-) -> npt.NDArray[np.uint64]:\n- \"\"\"\n- Given a 1d array, return an array of deterministic integers.\n-\n- Parameters\n- ----------\n- vals : ndarray or ExtensionArray\n- encoding : str, default 'utf8'\n- Encoding for data & key when strings.\n- hash_key : str, default _default_hash_key\n- Hash_key for string key to encode.\n- categorize : bool, default True\n- Whether to first categorize object arrays before hashing. This is more\n- efficient when the array contains duplicate values.\n-\n- Returns\n- -------\n- ndarray[np.uint64, ndim=1]\n- Hashed values, same length as the vals.\n- \"\"\"\n- if not hasattr(vals, \"dtype\"):\n- raise TypeError(\"must pass a ndarray-like\")\n- dtype = vals.dtype\n-\n- # For categoricals, we hash the categories, then remap the codes to the\n- # hash values. (This check is above the complex check so that we don't ask\n- # numpy if categorical is a subdtype of complex, as it will choke).\n- if is_categorical_dtype(dtype):\n- vals = cast(\"Categorical\", vals)\n- return _hash_categorical(vals, encoding, hash_key)\n-\n- elif isinstance(vals, ABCExtensionArray):\n- vals, _ = vals._values_for_factorize()\n-\n- elif not isinstance(vals, np.ndarray):\n- # GH#42003\n- raise TypeError(\n- \"hash_array requires np.ndarray or ExtensionArray, not \"\n- f\"{type(vals).__name__}. Use hash_pandas_object instead.\"\n- )\n-\n- return _hash_ndarray(vals, encoding, hash_key, categorize)\n-\n-\n-def _hash_ndarray(\n- vals: np.ndarray,\n- encoding: str = \"utf8\",\n- hash_key: str = _default_hash_key,\n- categorize: bool = True,\n-) -> npt.NDArray[np.uint64]:\n- \"\"\"\n- See hash_array.__doc__.\n- \"\"\"\n- dtype = vals.dtype\n-\n- # we'll be working with everything as 64-bit values, so handle this\n- # 128-bit value early\n- if np.issubdtype(dtype, np.complex128):\n- return hash_array(np.real(vals)) + 23 * hash_array(np.imag(vals))\n-\n- # First, turn whatever array this is into unsigned 64-bit ints, if we can\n- # manage it.\n- elif dtype == bool:\n- vals = vals.astype(\"u8\")\n- elif issubclass(dtype.type, (np.datetime64, np.timedelta64)):\n- vals = vals.view(\"i8\").astype(\"u8\", copy=False)\n- elif issubclass(dtype.type, np.number) and dtype.itemsize <= 8:\n- vals = vals.view(f\"u{vals.dtype.itemsize}\").astype(\"u8\")\n- else:\n- # With repeated values, its MUCH faster to categorize object dtypes,\n- # then hash and rename categories. We allow skipping the categorization\n- # when the values are known/likely to be unique.\n- if categorize:\n- from pandas import (\n- Categorical,\n- Index,\n- factorize,\n- )\n-\n- codes, categories = factorize(vals, sort=False)\n- cat = Categorical(\n- codes, Index._with_infer(categories), ordered=False, fastpath=True\n- )\n- return _hash_categorical(cat, encoding, hash_key)\n-\n- try:\n- vals = hash_object_array(vals, hash_key, encoding)\n- except TypeError:\n- # we have mixed types\n- vals = hash_object_array(\n- vals.astype(str).astype(object), hash_key, encoding\n- )\n-\n- # Then, redistribute these 64-bit ints within the space of 64-bit ints\n- vals ^= vals >> 30\n- vals *= np.uint64(0xBF58476D1CE4E5B9)\n- vals ^= vals >> 27\n- vals *= np.uint64(0x94D049BB133111EB)\n- vals ^= vals >> 31\n- return vals\n+from pandas._core.util.hashing import *\ndiff --git a/pandas/core/util/numba_.py b/pandas/core/util/numba_.py\nindex be798e022ac6e..16b7b383f0ccd 100644\n--- a/pandas/core/util/numba_.py\n+++ b/pandas/core/util/numba_.py\n@@ -1,112 +1 @@\n-\"\"\"Common utilities for Numba operations\"\"\"\n-from __future__ import annotations\n-\n-import types\n-from typing import (\n- TYPE_CHECKING,\n- Callable,\n-)\n-\n-import numpy as np\n-\n-from pandas.compat._optional import import_optional_dependency\n-from pandas.errors import NumbaUtilError\n-\n-GLOBAL_USE_NUMBA: bool = False\n-\n-\n-def maybe_use_numba(engine: str | None) -> bool:\n- \"\"\"Signal whether to use numba routines.\"\"\"\n- return engine == \"numba\" or (engine is None and GLOBAL_USE_NUMBA)\n-\n-\n-def set_use_numba(enable: bool = False) -> None:\n- global GLOBAL_USE_NUMBA\n- if enable:\n- import_optional_dependency(\"numba\")\n- GLOBAL_USE_NUMBA = enable\n-\n-\n-def get_jit_arguments(\n- engine_kwargs: dict[str, bool] | None = None, kwargs: dict | None = None\n-) -> dict[str, bool]:\n- \"\"\"\n- Return arguments to pass to numba.JIT, falling back on pandas default JIT settings.\n-\n- Parameters\n- ----------\n- engine_kwargs : dict, default None\n- user passed keyword arguments for numba.JIT\n- kwargs : dict, default None\n- user passed keyword arguments to pass into the JITed function\n-\n- Returns\n- -------\n- dict[str, bool]\n- nopython, nogil, parallel\n-\n- Raises\n- ------\n- NumbaUtilError\n- \"\"\"\n- if engine_kwargs is None:\n- engine_kwargs = {}\n-\n- nopython = engine_kwargs.get(\"nopython\", True)\n- if kwargs and nopython:\n- raise NumbaUtilError(\n- \"numba does not support kwargs with nopython=True: \"\n- \"https://github.com/numba/numba/issues/2916\"\n- )\n- nogil = engine_kwargs.get(\"nogil\", False)\n- parallel = engine_kwargs.get(\"parallel\", False)\n- return {\"nopython\": nopython, \"nogil\": nogil, \"parallel\": parallel}\n-\n-\n-def jit_user_function(\n- func: Callable, nopython: bool, nogil: bool, parallel: bool\n-) -> Callable:\n- \"\"\"\n- JIT the user's function given the configurable arguments.\n-\n- Parameters\n- ----------\n- func : function\n- user defined function\n- nopython : bool\n- nopython parameter for numba.JIT\n- nogil : bool\n- nogil parameter for numba.JIT\n- parallel : bool\n- parallel parameter for numba.JIT\n-\n- Returns\n- -------\n- function\n- Numba JITed function\n- \"\"\"\n- if TYPE_CHECKING:\n- import numba\n- else:\n- numba = import_optional_dependency(\"numba\")\n-\n- if numba.extending.is_jitted(func):\n- # Don't jit a user passed jitted function\n- numba_func = func\n- else:\n-\n- @numba.generated_jit(nopython=nopython, nogil=nogil, parallel=parallel)\n- def numba_func(data, *_args):\n- if getattr(np, func.__name__, False) is func or isinstance(\n- func, types.BuiltinFunctionType\n- ):\n- jf = func\n- else:\n- jf = numba.jit(func, nopython=nopython, nogil=nogil)\n-\n- def impl(data, *_args):\n- return jf(data, *_args)\n-\n- return impl\n-\n- return numba_func\n+from pandas._core.util.numba_ import *\ndiff --git a/pandas/core/window/__init__.py b/pandas/core/window/__init__.py\nindex 8f42cd782c67f..3fa8cf87409e1 100644\n--- a/pandas/core/window/__init__.py\n+++ b/pandas/core/window/__init__.py\n@@ -1,13 +1 @@\n-from pandas.core.window.ewm import ( # noqa:F401\n- ExponentialMovingWindow,\n- ExponentialMovingWindowGroupby,\n-)\n-from pandas.core.window.expanding import ( # noqa:F401\n- Expanding,\n- ExpandingGroupby,\n-)\n-from pandas.core.window.rolling import ( # noqa:F401\n- Rolling,\n- RollingGroupby,\n- Window,\n-)\n+from pandas._core.window.__init__ import *\ndiff --git a/pandas/core/window/common.py b/pandas/core/window/common.py\nindex 15144116fa924..ebd48615edbca 100644\n--- a/pandas/core/window/common.py\n+++ b/pandas/core/window/common.py\n@@ -1,167 +1 @@\n-\"\"\"Common utility functions for rolling operations\"\"\"\n-from collections import defaultdict\n-from typing import cast\n-\n-import numpy as np\n-\n-from pandas.core.dtypes.generic import (\n- ABCDataFrame,\n- ABCSeries,\n-)\n-\n-from pandas.core.indexes.api import MultiIndex\n-\n-\n-def flex_binary_moment(arg1, arg2, f, pairwise=False):\n-\n- if isinstance(arg1, ABCSeries) and isinstance(arg2, ABCSeries):\n- X, Y = prep_binary(arg1, arg2)\n- return f(X, Y)\n-\n- elif isinstance(arg1, ABCDataFrame):\n- from pandas import DataFrame\n-\n- def dataframe_from_int_dict(data, frame_template):\n- result = DataFrame(data, index=frame_template.index)\n- if len(result.columns) > 0:\n- result.columns = frame_template.columns[result.columns]\n- return result\n-\n- results = {}\n- if isinstance(arg2, ABCDataFrame):\n- if pairwise is False:\n- if arg1 is arg2:\n- # special case in order to handle duplicate column names\n- for i in range(len(arg1.columns)):\n- results[i] = f(arg1.iloc[:, i], arg2.iloc[:, i])\n- return dataframe_from_int_dict(results, arg1)\n- else:\n- if not arg1.columns.is_unique:\n- raise ValueError(\"'arg1' columns are not unique\")\n- if not arg2.columns.is_unique:\n- raise ValueError(\"'arg2' columns are not unique\")\n- X, Y = arg1.align(arg2, join=\"outer\")\n- X, Y = prep_binary(X, Y)\n- res_columns = arg1.columns.union(arg2.columns)\n- for col in res_columns:\n- if col in X and col in Y:\n- results[col] = f(X[col], Y[col])\n- return DataFrame(results, index=X.index, columns=res_columns)\n- elif pairwise is True:\n- results = defaultdict(dict)\n- for i in range(len(arg1.columns)):\n- for j in range(len(arg2.columns)):\n- if j < i and arg2 is arg1:\n- # Symmetric case\n- results[i][j] = results[j][i]\n- else:\n- results[i][j] = f(\n- *prep_binary(arg1.iloc[:, i], arg2.iloc[:, j])\n- )\n-\n- from pandas import concat\n-\n- result_index = arg1.index.union(arg2.index)\n- if len(result_index):\n-\n- # construct result frame\n- result = concat(\n- [\n- concat(\n- [results[i][j] for j in range(len(arg2.columns))],\n- ignore_index=True,\n- )\n- for i in range(len(arg1.columns))\n- ],\n- ignore_index=True,\n- axis=1,\n- )\n- result.columns = arg1.columns\n-\n- # set the index and reorder\n- if arg2.columns.nlevels > 1:\n- # mypy needs to know columns is a MultiIndex, Index doesn't\n- # have levels attribute\n- arg2.columns = cast(MultiIndex, arg2.columns)\n- # GH 21157: Equivalent to MultiIndex.from_product(\n- # [result_index], <unique combinations of arg2.columns.levels>,\n- # )\n- # A normal MultiIndex.from_product will produce too many\n- # combinations.\n- result_level = np.tile(\n- result_index, len(result) // len(result_index)\n- )\n- arg2_levels = (\n- np.repeat(\n- arg2.columns.get_level_values(i),\n- len(result) // len(arg2.columns),\n- )\n- for i in range(arg2.columns.nlevels)\n- )\n- result_names = list(arg2.columns.names) + [result_index.name]\n- result.index = MultiIndex.from_arrays(\n- [*arg2_levels, result_level], names=result_names\n- )\n- # GH 34440\n- num_levels = len(result.index.levels)\n- new_order = [num_levels - 1] + list(range(num_levels - 1))\n- result = result.reorder_levels(new_order).sort_index()\n- else:\n- result.index = MultiIndex.from_product(\n- [range(len(arg2.columns)), range(len(result_index))]\n- )\n- result = result.swaplevel(1, 0).sort_index()\n- result.index = MultiIndex.from_product(\n- [result_index] + [arg2.columns]\n- )\n- else:\n-\n- # empty result\n- result = DataFrame(\n- index=MultiIndex(\n- levels=[arg1.index, arg2.columns], codes=[[], []]\n- ),\n- columns=arg2.columns,\n- dtype=\"float64\",\n- )\n-\n- # reset our index names to arg1 names\n- # reset our column names to arg2 names\n- # careful not to mutate the original names\n- result.columns = result.columns.set_names(arg1.columns.names)\n- result.index = result.index.set_names(\n- result_index.names + arg2.columns.names\n- )\n-\n- return result\n- else:\n- results = {\n- i: f(*prep_binary(arg1.iloc[:, i], arg2))\n- for i in range(len(arg1.columns))\n- }\n- return dataframe_from_int_dict(results, arg1)\n-\n- else:\n- return flex_binary_moment(arg2, arg1, f)\n-\n-\n-def zsqrt(x):\n- with np.errstate(all=\"ignore\"):\n- result = np.sqrt(x)\n- mask = x < 0\n-\n- if isinstance(x, ABCDataFrame):\n- if mask._values.any():\n- result[mask] = 0\n- else:\n- if mask.any():\n- result[mask] = 0\n-\n- return result\n-\n-\n-def prep_binary(arg1, arg2):\n- # mask out values, this also makes a common index...\n- X = arg1 + 0 * arg2\n- Y = arg2 + 0 * arg1\n- return X, Y\n+from pandas._core.window.common import *\ndiff --git a/pandas/core/window/doc.py b/pandas/core/window/doc.py\nindex 61cfa29ffc481..84ff352cf14ce 100644\n--- a/pandas/core/window/doc.py\n+++ b/pandas/core/window/doc.py\n@@ -1,134 +1 @@\n-\"\"\"Any shareable docstring components for rolling/expanding/ewm\"\"\"\n-from textwrap import dedent\n-\n-from pandas.core.shared_docs import _shared_docs\n-\n-_shared_docs = dict(**_shared_docs)\n-\n-\n-def create_section_header(header: str) -> str:\n- \"\"\"Create numpydoc section header\"\"\"\n- return \"\\n\".join((header, \"-\" * len(header))) + \"\\n\"\n-\n-\n-template_header = \"\\nCalculate the {window_method} {aggregation_description}.\\n\\n\"\n-\n-template_returns = dedent(\n- \"\"\"\n- Series or DataFrame\n- Return type is the same as the original object with ``np.float64`` dtype.\\n\n- \"\"\"\n-).replace(\"\\n\", \"\", 1)\n-\n-template_see_also = dedent(\n- \"\"\"\n- pandas.Series.{window_method} : Calling {window_method} with Series data.\n- pandas.DataFrame.{window_method} : Calling {window_method} with DataFrames.\n- pandas.Series.{agg_method} : Aggregating {agg_method} for Series.\n- pandas.DataFrame.{agg_method} : Aggregating {agg_method} for DataFrame.\\n\n- \"\"\"\n-).replace(\"\\n\", \"\", 1)\n-\n-kwargs_numeric_only = dedent(\n- \"\"\"\n- numeric_only : bool, default False\n- Include only float, int, boolean columns.\n-\n- .. versionadded:: 1.5.0\\n\n- \"\"\"\n-).replace(\"\\n\", \"\", 1)\n-\n-args_compat = dedent(\n- \"\"\"\n- *args\n- For NumPy compatibility and will not have an effect on the result.\\n\n- \"\"\"\n-).replace(\"\\n\", \"\", 1)\n-\n-kwargs_compat = dedent(\n- \"\"\"\n- **kwargs\n- For NumPy compatibility and will not have an effect on the result.\\n\n- \"\"\"\n-).replace(\"\\n\", \"\", 1)\n-\n-kwargs_scipy = dedent(\n- \"\"\"\n- **kwargs\n- Keyword arguments to configure the ``SciPy`` weighted window type.\\n\n- \"\"\"\n-).replace(\"\\n\", \"\", 1)\n-\n-window_apply_parameters = dedent(\n- \"\"\"\n- func : function\n- Must produce a single value from an ndarray input if ``raw=True``\n- or a single value from a Series if ``raw=False``. Can also accept a\n- Numba JIT function with ``engine='numba'`` specified.\n-\n- .. versionchanged:: 1.0.0\n-\n- raw : bool, default False\n- * ``False`` : passes each row or column as a Series to the\n- function.\n- * ``True`` : the passed function will receive ndarray\n- objects instead.\n- If you are just applying a NumPy reduction function this will\n- achieve much better performance.\n-\n- engine : str, default None\n- * ``'cython'`` : Runs rolling apply through C-extensions from cython.\n- * ``'numba'`` : Runs rolling apply through JIT compiled code from numba.\n- Only available when ``raw`` is set to ``True``.\n- * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba``\n-\n- .. versionadded:: 1.0.0\n-\n- engine_kwargs : dict, default None\n- * For ``'cython'`` engine, there are no accepted ``engine_kwargs``\n- * For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil``\n- and ``parallel`` dictionary keys. The values must either be ``True`` or\n- ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is\n- ``{{'nopython': True, 'nogil': False, 'parallel': False}}`` and will be\n- applied to both the ``func`` and the ``apply`` rolling aggregation.\n-\n- .. versionadded:: 1.0.0\n-\n- args : tuple, default None\n- Positional arguments to be passed into func.\n-\n- kwargs : dict, default None\n- Keyword arguments to be passed into func.\\n\n- \"\"\"\n-).replace(\"\\n\", \"\", 1)\n-\n-numba_notes = (\n- \"See :ref:`window.numba_engine` and :ref:`enhancingperf.numba` for \"\n- \"extended documentation and performance considerations for the Numba engine.\\n\\n\"\n-)\n-\n-\n-def window_agg_numba_parameters(version: str = \"1.3\") -> str:\n- return (\n- dedent(\n- \"\"\"\n- engine : str, default None\n- * ``'cython'`` : Runs the operation through C-extensions from cython.\n- * ``'numba'`` : Runs the operation through JIT compiled code from numba.\n- * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba``\n-\n- .. versionadded:: {version}.0\n-\n- engine_kwargs : dict, default None\n- * For ``'cython'`` engine, there are no accepted ``engine_kwargs``\n- * For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil``\n- and ``parallel`` dictionary keys. The values must either be ``True`` or\n- ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is\n- ``{{'nopython': True, 'nogil': False, 'parallel': False}}``\n-\n- .. versionadded:: {version}.0\\n\n- \"\"\"\n- )\n- .replace(\"\\n\", \"\", 1)\n- .replace(\"{version}\", version)\n- )\n+from pandas._core.window.doc import *\ndiff --git a/pandas/core/window/ewm.py b/pandas/core/window/ewm.py\nindex a153761f377b3..1a3d6e4c6a7dc 100644\n--- a/pandas/core/window/ewm.py\n+++ b/pandas/core/window/ewm.py\n@@ -1,1072 +1 @@\n-from __future__ import annotations\n-\n-import datetime\n-from functools import partial\n-from textwrap import dedent\n-from typing import (\n- TYPE_CHECKING,\n- cast,\n-)\n-import warnings\n-\n-import numpy as np\n-\n-from pandas._libs.tslibs import Timedelta\n-import pandas._libs.window.aggregations as window_aggregations\n-from pandas._typing import (\n- Axis,\n- TimedeltaConvertibleTypes,\n-)\n-\n-if TYPE_CHECKING:\n- from pandas import DataFrame, Series\n- from pandas.core.generic import NDFrame\n-\n-from pandas.compat.numpy import function as nv\n-from pandas.util._decorators import doc\n-from pandas.util._exceptions import find_stack_level\n-\n-from pandas.core.dtypes.common import (\n- is_datetime64_ns_dtype,\n- is_numeric_dtype,\n-)\n-from pandas.core.dtypes.missing import isna\n-\n-import pandas.core.common as common # noqa: PDF018\n-from pandas.core.indexers.objects import (\n- BaseIndexer,\n- ExponentialMovingWindowIndexer,\n- GroupbyIndexer,\n-)\n-from pandas.core.util.numba_ import (\n- get_jit_arguments,\n- maybe_use_numba,\n-)\n-from pandas.core.window.common import zsqrt\n-from pandas.core.window.doc import (\n- _shared_docs,\n- args_compat,\n- create_section_header,\n- kwargs_compat,\n- kwargs_numeric_only,\n- numba_notes,\n- template_header,\n- template_returns,\n- template_see_also,\n- window_agg_numba_parameters,\n-)\n-from pandas.core.window.numba_ import (\n- generate_numba_ewm_func,\n- generate_numba_ewm_table_func,\n-)\n-from pandas.core.window.online import (\n- EWMMeanState,\n- generate_online_numba_ewma_func,\n-)\n-from pandas.core.window.rolling import (\n- BaseWindow,\n- BaseWindowGroupby,\n-)\n-\n-\n-def get_center_of_mass(\n- comass: float | None,\n- span: float | None,\n- halflife: float | None,\n- alpha: float | None,\n-) -> float:\n- valid_count = common.count_not_none(comass, span, halflife, alpha)\n- if valid_count > 1:\n- raise ValueError(\"comass, span, halflife, and alpha are mutually exclusive\")\n-\n- # Convert to center of mass; domain checks ensure 0 < alpha <= 1\n- if comass is not None:\n- if comass < 0:\n- raise ValueError(\"comass must satisfy: comass >= 0\")\n- elif span is not None:\n- if span < 1:\n- raise ValueError(\"span must satisfy: span >= 1\")\n- comass = (span - 1) / 2\n- elif halflife is not None:\n- if halflife <= 0:\n- raise ValueError(\"halflife must satisfy: halflife > 0\")\n- decay = 1 - np.exp(np.log(0.5) / halflife)\n- comass = 1 / decay - 1\n- elif alpha is not None:\n- if alpha <= 0 or alpha > 1:\n- raise ValueError(\"alpha must satisfy: 0 < alpha <= 1\")\n- comass = (1 - alpha) / alpha\n- else:\n- raise ValueError(\"Must pass one of comass, span, halflife, or alpha\")\n-\n- return float(comass)\n-\n-\n-def _calculate_deltas(\n- times: str | np.ndarray | NDFrame | None,\n- halflife: float | TimedeltaConvertibleTypes | None,\n-) -> np.ndarray:\n- \"\"\"\n- Return the diff of the times divided by the half-life. These values are used in\n- the calculation of the ewm mean.\n-\n- Parameters\n- ----------\n- times : str, np.ndarray, Series, default None\n- Times corresponding to the observations. Must be monotonically increasing\n- and ``datetime64[ns]`` dtype.\n- halflife : float, str, timedelta, optional\n- Half-life specifying the decay\n-\n- Returns\n- -------\n- np.ndarray\n- Diff of the times divided by the half-life\n- \"\"\"\n- # error: Item \"str\" of \"Union[str, ndarray, NDFrameT, None]\" has no\n- # attribute \"view\"\n- # error: Item \"None\" of \"Union[str, ndarray, NDFrameT, None]\" has no\n- # attribute \"view\"\n- _times = np.asarray(\n- times.view(np.int64), dtype=np.float64 # type: ignore[union-attr]\n- )\n- _halflife = float(Timedelta(halflife).value)\n- return np.diff(_times) / _halflife\n-\n-\n-class ExponentialMovingWindow(BaseWindow):\n- r\"\"\"\n- Provide exponentially weighted (EW) calculations.\n-\n- Exactly one of ``com``, ``span``, ``halflife``, or ``alpha`` must be\n- provided if ``times`` is not provided. If ``times`` is provided,\n- ``halflife`` and one of ``com``, ``span`` or ``alpha`` may be provided.\n-\n- Parameters\n- ----------\n- com : float, optional\n- Specify decay in terms of center of mass\n-\n- :math:`\\alpha = 1 / (1 + com)`, for :math:`com \\geq 0`.\n-\n- span : float, optional\n- Specify decay in terms of span\n-\n- :math:`\\alpha = 2 / (span + 1)`, for :math:`span \\geq 1`.\n-\n- halflife : float, str, timedelta, optional\n- Specify decay in terms of half-life\n-\n- :math:`\\alpha = 1 - \\exp\\left(-\\ln(2) / halflife\\right)`, for\n- :math:`halflife > 0`.\n-\n- If ``times`` is specified, a timedelta convertible unit over which an\n- observation decays to half its value. Only applicable to ``mean()``,\n- and halflife value will not apply to the other functions.\n-\n- .. versionadded:: 1.1.0\n-\n- alpha : float, optional\n- Specify smoothing factor :math:`\\alpha` directly\n-\n- :math:`0 < \\alpha \\leq 1`.\n-\n- min_periods : int, default 0\n- Minimum number of observations in window required to have a value;\n- otherwise, result is ``np.nan``.\n-\n- adjust : bool, default True\n- Divide by decaying adjustment factor in beginning periods to account\n- for imbalance in relative weightings (viewing EWMA as a moving average).\n-\n- - When ``adjust=True`` (default), the EW function is calculated using weights\n- :math:`w_i = (1 - \\alpha)^i`. For example, the EW moving average of the series\n- [:math:`x_0, x_1, ..., x_t`] would be:\n-\n- .. math::\n- y_t = \\frac{x_t + (1 - \\alpha)x_{t-1} + (1 - \\alpha)^2 x_{t-2} + ... + (1 -\n- \\alpha)^t x_0}{1 + (1 - \\alpha) + (1 - \\alpha)^2 + ... + (1 - \\alpha)^t}\n-\n- - When ``adjust=False``, the exponentially weighted function is calculated\n- recursively:\n-\n- .. math::\n- \\begin{split}\n- y_0 &= x_0\\\\\n- y_t &= (1 - \\alpha) y_{t-1} + \\alpha x_t,\n- \\end{split}\n- ignore_na : bool, default False\n- Ignore missing values when calculating weights.\n-\n- - When ``ignore_na=False`` (default), weights are based on absolute positions.\n- For example, the weights of :math:`x_0` and :math:`x_2` used in calculating\n- the final weighted average of [:math:`x_0`, None, :math:`x_2`] are\n- :math:`(1-\\alpha)^2` and :math:`1` if ``adjust=True``, and\n- :math:`(1-\\alpha)^2` and :math:`\\alpha` if ``adjust=False``.\n-\n- - When ``ignore_na=True``, weights are based\n- on relative positions. For example, the weights of :math:`x_0` and :math:`x_2`\n- used in calculating the final weighted average of\n- [:math:`x_0`, None, :math:`x_2`] are :math:`1-\\alpha` and :math:`1` if\n- ``adjust=True``, and :math:`1-\\alpha` and :math:`\\alpha` if ``adjust=False``.\n-\n- axis : {0, 1}, default 0\n- If ``0`` or ``'index'``, calculate across the rows.\n-\n- If ``1`` or ``'columns'``, calculate across the columns.\n-\n- For `Series` this parameter is unused and defaults to 0.\n-\n- times : str, np.ndarray, Series, default None\n-\n- .. versionadded:: 1.1.0\n-\n- Only applicable to ``mean()``.\n-\n- Times corresponding to the observations. Must be monotonically increasing and\n- ``datetime64[ns]`` dtype.\n-\n- If 1-D array like, a sequence with the same shape as the observations.\n-\n- .. deprecated:: 1.4.0\n- If str, the name of the column in the DataFrame representing the times.\n-\n- method : str {'single', 'table'}, default 'single'\n- .. versionadded:: 1.4.0\n-\n- Execute the rolling operation per single column or row (``'single'``)\n- or over the entire object (``'table'``).\n-\n- This argument is only implemented when specifying ``engine='numba'``\n- in the method call.\n-\n- Only applicable to ``mean()``\n-\n- Returns\n- -------\n- ``ExponentialMovingWindow`` subclass\n-\n- See Also\n- --------\n- rolling : Provides rolling window calculations.\n- expanding : Provides expanding transformations.\n-\n- Notes\n- -----\n- See :ref:`Windowing Operations <window.exponentially_weighted>`\n- for further usage details and examples.\n-\n- Examples\n- --------\n- >>> df = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]})\n- >>> df\n- B\n- 0 0.0\n- 1 1.0\n- 2 2.0\n- 3 NaN\n- 4 4.0\n-\n- >>> df.ewm(com=0.5).mean()\n- B\n- 0 0.000000\n- 1 0.750000\n- 2 1.615385\n- 3 1.615385\n- 4 3.670213\n- >>> df.ewm(alpha=2 / 3).mean()\n- B\n- 0 0.000000\n- 1 0.750000\n- 2 1.615385\n- 3 1.615385\n- 4 3.670213\n-\n- **adjust**\n-\n- >>> df.ewm(com=0.5, adjust=True).mean()\n- B\n- 0 0.000000\n- 1 0.750000\n- 2 1.615385\n- 3 1.615385\n- 4 3.670213\n- >>> df.ewm(com=0.5, adjust=False).mean()\n- B\n- 0 0.000000\n- 1 0.666667\n- 2 1.555556\n- 3 1.555556\n- 4 3.650794\n-\n- **ignore_na**\n-\n- >>> df.ewm(com=0.5, ignore_na=True).mean()\n- B\n- 0 0.000000\n- 1 0.750000\n- 2 1.615385\n- 3 1.615385\n- 4 3.225000\n- >>> df.ewm(com=0.5, ignore_na=False).mean()\n- B\n- 0 0.000000\n- 1 0.750000\n- 2 1.615385\n- 3 1.615385\n- 4 3.670213\n-\n- **times**\n-\n- Exponentially weighted mean with weights calculated with a timedelta ``halflife``\n- relative to ``times``.\n-\n- >>> times = ['2020-01-01', '2020-01-03', '2020-01-10', '2020-01-15', '2020-01-17']\n- >>> df.ewm(halflife='4 days', times=pd.DatetimeIndex(times)).mean()\n- B\n- 0 0.000000\n- 1 0.585786\n- 2 1.523889\n- 3 1.523889\n- 4 3.233686\n- \"\"\"\n-\n- _attributes = [\n- \"com\",\n- \"span\",\n- \"halflife\",\n- \"alpha\",\n- \"min_periods\",\n- \"adjust\",\n- \"ignore_na\",\n- \"axis\",\n- \"times\",\n- \"method\",\n- ]\n-\n- def __init__(\n- self,\n- obj: NDFrame,\n- com: float | None = None,\n- span: float | None = None,\n- halflife: float | TimedeltaConvertibleTypes | None = None,\n- alpha: float | None = None,\n- min_periods: int | None = 0,\n- adjust: bool = True,\n- ignore_na: bool = False,\n- axis: Axis = 0,\n- times: str | np.ndarray | NDFrame | None = None,\n- method: str = \"single\",\n- *,\n- selection=None,\n- ) -> None:\n- super().__init__(\n- obj=obj,\n- min_periods=1 if min_periods is None else max(int(min_periods), 1),\n- on=None,\n- center=False,\n- closed=None,\n- method=method,\n- axis=axis,\n- selection=selection,\n- )\n- self.com = com\n- self.span = span\n- self.halflife = halflife\n- self.alpha = alpha\n- self.adjust = adjust\n- self.ignore_na = ignore_na\n- self.times = times\n- if self.times is not None:\n- if not self.adjust:\n- raise NotImplementedError(\"times is not supported with adjust=False.\")\n- if isinstance(self.times, str):\n- warnings.warn(\n- (\n- \"Specifying times as a string column label is deprecated \"\n- \"and will be removed in a future version. Pass the column \"\n- \"into times instead.\"\n- ),\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n- # self.times cannot be str anymore\n- self.times = cast(\"Series\", self._selected_obj[self.times])\n- if not is_datetime64_ns_dtype(self.times):\n- raise ValueError(\"times must be datetime64[ns] dtype.\")\n- if len(self.times) != len(obj):\n- raise ValueError(\"times must be the same length as the object.\")\n- if not isinstance(self.halflife, (str, datetime.timedelta, np.timedelta64)):\n- raise ValueError(\"halflife must be a timedelta convertible object\")\n- if isna(self.times).any():\n- raise ValueError(\"Cannot convert NaT values to integer\")\n- self._deltas = _calculate_deltas(self.times, self.halflife)\n- # Halflife is no longer applicable when calculating COM\n- # But allow COM to still be calculated if the user passes other decay args\n- if common.count_not_none(self.com, self.span, self.alpha) > 0:\n- self._com = get_center_of_mass(self.com, self.span, None, self.alpha)\n- else:\n- self._com = 1.0\n- else:\n- if self.halflife is not None and isinstance(\n- self.halflife, (str, datetime.timedelta, np.timedelta64)\n- ):\n- raise ValueError(\n- \"halflife can only be a timedelta convertible argument if \"\n- \"times is not None.\"\n- )\n- # Without times, points are equally spaced\n- self._deltas = np.ones(\n- max(self.obj.shape[self.axis] - 1, 0), dtype=np.float64\n- )\n- self._com = get_center_of_mass(\n- # error: Argument 3 to \"get_center_of_mass\" has incompatible type\n- # \"Union[float, Any, None, timedelta64, signedinteger[_64Bit]]\";\n- # expected \"Optional[float]\"\n- self.com,\n- self.span,\n- self.halflife, # type: ignore[arg-type]\n- self.alpha,\n- )\n-\n- def _check_window_bounds(\n- self, start: np.ndarray, end: np.ndarray, num_vals: int\n- ) -> None:\n- # emw algorithms are iterative with each point\n- # ExponentialMovingWindowIndexer \"bounds\" are the entire window\n- pass\n-\n- def _get_window_indexer(self) -> BaseIndexer:\n- \"\"\"\n- Return an indexer class that will compute the window start and end bounds\n- \"\"\"\n- return ExponentialMovingWindowIndexer()\n-\n- def online(self, engine=\"numba\", engine_kwargs=None):\n- \"\"\"\n- Return an ``OnlineExponentialMovingWindow`` object to calculate\n- exponentially moving window aggregations in an online method.\n-\n- .. versionadded:: 1.3.0\n-\n- Parameters\n- ----------\n- engine: str, default ``'numba'``\n- Execution engine to calculate online aggregations.\n- Applies to all supported aggregation methods.\n-\n- engine_kwargs : dict, default None\n- Applies to all supported aggregation methods.\n-\n- * For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil``\n- and ``parallel`` dictionary keys. The values must either be ``True`` or\n- ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is\n- ``{{'nopython': True, 'nogil': False, 'parallel': False}}`` and will be\n- applied to the function\n-\n- Returns\n- -------\n- OnlineExponentialMovingWindow\n- \"\"\"\n- return OnlineExponentialMovingWindow(\n- obj=self.obj,\n- com=self.com,\n- span=self.span,\n- halflife=self.halflife,\n- alpha=self.alpha,\n- min_periods=self.min_periods,\n- adjust=self.adjust,\n- ignore_na=self.ignore_na,\n- axis=self.axis,\n- times=self.times,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- selection=self._selection,\n- )\n-\n- @doc(\n- _shared_docs[\"aggregate\"],\n- see_also=dedent(\n- \"\"\"\n- See Also\n- --------\n- pandas.DataFrame.rolling.aggregate\n- \"\"\"\n- ),\n- examples=dedent(\n- \"\"\"\n- Examples\n- --------\n- >>> df = pd.DataFrame({\"A\": [1, 2, 3], \"B\": [4, 5, 6], \"C\": [7, 8, 9]})\n- >>> df\n- A B C\n- 0 1 4 7\n- 1 2 5 8\n- 2 3 6 9\n-\n- >>> df.ewm(alpha=0.5).mean()\n- A B C\n- 0 1.000000 4.000000 7.000000\n- 1 1.666667 4.666667 7.666667\n- 2 2.428571 5.428571 8.428571\n- \"\"\"\n- ),\n- klass=\"Series/Dataframe\",\n- axis=\"\",\n- )\n- def aggregate(self, func, *args, **kwargs):\n- return super().aggregate(func, *args, **kwargs)\n-\n- agg = aggregate\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- args_compat,\n- window_agg_numba_parameters(),\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also,\n- create_section_header(\"Notes\"),\n- numba_notes.replace(\"\\n\", \"\", 1),\n- window_method=\"ewm\",\n- aggregation_description=\"(exponential weighted moment) mean\",\n- agg_method=\"mean\",\n- )\n- def mean(\n- self,\n- numeric_only: bool = False,\n- *args,\n- engine=None,\n- engine_kwargs=None,\n- **kwargs,\n- ):\n- if maybe_use_numba(engine):\n- if self.method == \"single\":\n- func = generate_numba_ewm_func\n- else:\n- func = generate_numba_ewm_table_func\n- ewm_func = func(\n- **get_jit_arguments(engine_kwargs),\n- com=self._com,\n- adjust=self.adjust,\n- ignore_na=self.ignore_na,\n- deltas=tuple(self._deltas),\n- normalize=True,\n- )\n- return self._apply(ewm_func, name=\"mean\")\n- elif engine in (\"cython\", None):\n- if engine_kwargs is not None:\n- raise ValueError(\"cython engine does not accept engine_kwargs\")\n- nv.validate_window_func(\"mean\", args, kwargs)\n-\n- deltas = None if self.times is None else self._deltas\n- window_func = partial(\n- window_aggregations.ewm,\n- com=self._com,\n- adjust=self.adjust,\n- ignore_na=self.ignore_na,\n- deltas=deltas,\n- normalize=True,\n- )\n- return self._apply(window_func, name=\"mean\", numeric_only=numeric_only)\n- else:\n- raise ValueError(\"engine must be either 'numba' or 'cython'\")\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- args_compat,\n- window_agg_numba_parameters(),\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also,\n- create_section_header(\"Notes\"),\n- numba_notes.replace(\"\\n\", \"\", 1),\n- window_method=\"ewm\",\n- aggregation_description=\"(exponential weighted moment) sum\",\n- agg_method=\"sum\",\n- )\n- def sum(\n- self,\n- numeric_only: bool = False,\n- *args,\n- engine=None,\n- engine_kwargs=None,\n- **kwargs,\n- ):\n- if not self.adjust:\n- raise NotImplementedError(\"sum is not implemented with adjust=False\")\n- if maybe_use_numba(engine):\n- if self.method == \"single\":\n- func = generate_numba_ewm_func\n- else:\n- func = generate_numba_ewm_table_func\n- ewm_func = func(\n- **get_jit_arguments(engine_kwargs),\n- com=self._com,\n- adjust=self.adjust,\n- ignore_na=self.ignore_na,\n- deltas=tuple(self._deltas),\n- normalize=False,\n- )\n- return self._apply(ewm_func, name=\"sum\")\n- elif engine in (\"cython\", None):\n- if engine_kwargs is not None:\n- raise ValueError(\"cython engine does not accept engine_kwargs\")\n- nv.validate_window_func(\"sum\", args, kwargs)\n-\n- deltas = None if self.times is None else self._deltas\n- window_func = partial(\n- window_aggregations.ewm,\n- com=self._com,\n- adjust=self.adjust,\n- ignore_na=self.ignore_na,\n- deltas=deltas,\n- normalize=False,\n- )\n- return self._apply(window_func, name=\"sum\", numeric_only=numeric_only)\n- else:\n- raise ValueError(\"engine must be either 'numba' or 'cython'\")\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- dedent(\n- \"\"\"\n- bias : bool, default False\n- Use a standard estimation bias correction.\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- kwargs_numeric_only,\n- args_compat,\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also[:-1],\n- window_method=\"ewm\",\n- aggregation_description=\"(exponential weighted moment) standard deviation\",\n- agg_method=\"std\",\n- )\n- def std(self, bias: bool = False, numeric_only: bool = False, *args, **kwargs):\n- nv.validate_window_func(\"std\", args, kwargs)\n- if (\n- numeric_only\n- and self._selected_obj.ndim == 1\n- and not is_numeric_dtype(self._selected_obj.dtype)\n- ):\n- # Raise directly so error message says std instead of var\n- raise NotImplementedError(\n- f\"{type(self).__name__}.std does not implement numeric_only\"\n- )\n- return zsqrt(self.var(bias=bias, numeric_only=numeric_only, **kwargs))\n-\n- def vol(self, bias: bool = False, *args, **kwargs):\n- warnings.warn(\n- (\n- \"vol is deprecated will be removed in a future version. \"\n- \"Use std instead.\"\n- ),\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n- return self.std(bias, *args, **kwargs)\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- dedent(\n- \"\"\"\n- bias : bool, default False\n- Use a standard estimation bias correction.\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- kwargs_numeric_only,\n- args_compat,\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also[:-1],\n- window_method=\"ewm\",\n- aggregation_description=\"(exponential weighted moment) variance\",\n- agg_method=\"var\",\n- )\n- def var(self, bias: bool = False, numeric_only: bool = False, *args, **kwargs):\n- nv.validate_window_func(\"var\", args, kwargs)\n- window_func = window_aggregations.ewmcov\n- wfunc = partial(\n- window_func,\n- com=self._com,\n- adjust=self.adjust,\n- ignore_na=self.ignore_na,\n- bias=bias,\n- )\n-\n- def var_func(values, begin, end, min_periods):\n- return wfunc(values, begin, end, min_periods, values)\n-\n- return self._apply(var_func, name=\"var\", numeric_only=numeric_only)\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- dedent(\n- \"\"\"\n- other : Series or DataFrame , optional\n- If not supplied then will default to self and produce pairwise\n- output.\n- pairwise : bool, default None\n- If False then only matching columns between self and other will be\n- used and the output will be a DataFrame.\n- If True then all pairwise combinations will be calculated and the\n- output will be a MultiIndex DataFrame in the case of DataFrame\n- inputs. In the case of missing elements, only complete pairwise\n- observations will be used.\n- bias : bool, default False\n- Use a standard estimation bias correction.\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- kwargs_numeric_only,\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also[:-1],\n- window_method=\"ewm\",\n- aggregation_description=\"(exponential weighted moment) sample covariance\",\n- agg_method=\"cov\",\n- )\n- def cov(\n- self,\n- other: DataFrame | Series | None = None,\n- pairwise: bool | None = None,\n- bias: bool = False,\n- numeric_only: bool = False,\n- **kwargs,\n- ):\n- from pandas import Series\n-\n- self._validate_numeric_only(\"cov\", numeric_only)\n-\n- def cov_func(x, y):\n- x_array = self._prep_values(x)\n- y_array = self._prep_values(y)\n- window_indexer = self._get_window_indexer()\n- min_periods = (\n- self.min_periods\n- if self.min_periods is not None\n- else window_indexer.window_size\n- )\n- start, end = window_indexer.get_window_bounds(\n- num_values=len(x_array),\n- min_periods=min_periods,\n- center=self.center,\n- closed=self.closed,\n- step=self.step,\n- )\n- result = window_aggregations.ewmcov(\n- x_array,\n- start,\n- end,\n- # error: Argument 4 to \"ewmcov\" has incompatible type\n- # \"Optional[int]\"; expected \"int\"\n- self.min_periods, # type: ignore[arg-type]\n- y_array,\n- self._com,\n- self.adjust,\n- self.ignore_na,\n- bias,\n- )\n- return Series(result, index=x.index, name=x.name)\n-\n- return self._apply_pairwise(\n- self._selected_obj, other, pairwise, cov_func, numeric_only\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- dedent(\n- \"\"\"\n- other : Series or DataFrame, optional\n- If not supplied then will default to self and produce pairwise\n- output.\n- pairwise : bool, default None\n- If False then only matching columns between self and other will be\n- used and the output will be a DataFrame.\n- If True then all pairwise combinations will be calculated and the\n- output will be a MultiIndex DataFrame in the case of DataFrame\n- inputs. In the case of missing elements, only complete pairwise\n- observations will be used.\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- kwargs_numeric_only,\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also[:-1],\n- window_method=\"ewm\",\n- aggregation_description=\"(exponential weighted moment) sample correlation\",\n- agg_method=\"corr\",\n- )\n- def corr(\n- self,\n- other: DataFrame | Series | None = None,\n- pairwise: bool | None = None,\n- numeric_only: bool = False,\n- **kwargs,\n- ):\n- from pandas import Series\n-\n- self._validate_numeric_only(\"corr\", numeric_only)\n-\n- def cov_func(x, y):\n- x_array = self._prep_values(x)\n- y_array = self._prep_values(y)\n- window_indexer = self._get_window_indexer()\n- min_periods = (\n- self.min_periods\n- if self.min_periods is not None\n- else window_indexer.window_size\n- )\n- start, end = window_indexer.get_window_bounds(\n- num_values=len(x_array),\n- min_periods=min_periods,\n- center=self.center,\n- closed=self.closed,\n- step=self.step,\n- )\n-\n- def _cov(X, Y):\n- return window_aggregations.ewmcov(\n- X,\n- start,\n- end,\n- min_periods,\n- Y,\n- self._com,\n- self.adjust,\n- self.ignore_na,\n- True,\n- )\n-\n- with np.errstate(all=\"ignore\"):\n- cov = _cov(x_array, y_array)\n- x_var = _cov(x_array, x_array)\n- y_var = _cov(y_array, y_array)\n- result = cov / zsqrt(x_var * y_var)\n- return Series(result, index=x.index, name=x.name)\n-\n- return self._apply_pairwise(\n- self._selected_obj, other, pairwise, cov_func, numeric_only\n- )\n-\n-\n-class ExponentialMovingWindowGroupby(BaseWindowGroupby, ExponentialMovingWindow):\n- \"\"\"\n- Provide an exponential moving window groupby implementation.\n- \"\"\"\n-\n- _attributes = ExponentialMovingWindow._attributes + BaseWindowGroupby._attributes\n-\n- def __init__(self, obj, *args, _grouper=None, **kwargs) -> None:\n- super().__init__(obj, *args, _grouper=_grouper, **kwargs)\n-\n- if not obj.empty and self.times is not None:\n- # sort the times and recalculate the deltas according to the groups\n- groupby_order = np.concatenate(list(self._grouper.indices.values()))\n- self._deltas = _calculate_deltas(\n- self.times.take(groupby_order), # type: ignore[union-attr]\n- self.halflife,\n- )\n-\n- def _get_window_indexer(self) -> GroupbyIndexer:\n- \"\"\"\n- Return an indexer class that will compute the window start and end bounds\n-\n- Returns\n- -------\n- GroupbyIndexer\n- \"\"\"\n- window_indexer = GroupbyIndexer(\n- groupby_indices=self._grouper.indices,\n- window_indexer=ExponentialMovingWindowIndexer,\n- )\n- return window_indexer\n-\n-\n-class OnlineExponentialMovingWindow(ExponentialMovingWindow):\n- def __init__(\n- self,\n- obj: NDFrame,\n- com: float | None = None,\n- span: float | None = None,\n- halflife: float | TimedeltaConvertibleTypes | None = None,\n- alpha: float | None = None,\n- min_periods: int | None = 0,\n- adjust: bool = True,\n- ignore_na: bool = False,\n- axis: Axis = 0,\n- times: str | np.ndarray | NDFrame | None = None,\n- engine: str = \"numba\",\n- engine_kwargs: dict[str, bool] | None = None,\n- *,\n- selection=None,\n- ) -> None:\n- if times is not None:\n- raise NotImplementedError(\n- \"times is not implemented with online operations.\"\n- )\n- super().__init__(\n- obj=obj,\n- com=com,\n- span=span,\n- halflife=halflife,\n- alpha=alpha,\n- min_periods=min_periods,\n- adjust=adjust,\n- ignore_na=ignore_na,\n- axis=axis,\n- times=times,\n- selection=selection,\n- )\n- self._mean = EWMMeanState(\n- self._com, self.adjust, self.ignore_na, self.axis, obj.shape\n- )\n- if maybe_use_numba(engine):\n- self.engine = engine\n- self.engine_kwargs = engine_kwargs\n- else:\n- raise ValueError(\"'numba' is the only supported engine\")\n-\n- def reset(self):\n- \"\"\"\n- Reset the state captured by `update` calls.\n- \"\"\"\n- self._mean.reset()\n-\n- def aggregate(self, func, *args, **kwargs):\n- return NotImplementedError\n-\n- def std(self, bias: bool = False, *args, **kwargs):\n- return NotImplementedError\n-\n- def corr(\n- self,\n- other: DataFrame | Series | None = None,\n- pairwise: bool | None = None,\n- numeric_only: bool = False,\n- **kwargs,\n- ):\n- return NotImplementedError\n-\n- def cov(\n- self,\n- other: DataFrame | Series | None = None,\n- pairwise: bool | None = None,\n- bias: bool = False,\n- numeric_only: bool = False,\n- **kwargs,\n- ):\n- return NotImplementedError\n-\n- def var(self, bias: bool = False, *args, **kwargs):\n- return NotImplementedError\n-\n- def mean(self, *args, update=None, update_times=None, **kwargs):\n- \"\"\"\n- Calculate an online exponentially weighted mean.\n-\n- Parameters\n- ----------\n- update: DataFrame or Series, default None\n- New values to continue calculating the\n- exponentially weighted mean from the last values and weights.\n- Values should be float64 dtype.\n-\n- ``update`` needs to be ``None`` the first time the\n- exponentially weighted mean is calculated.\n-\n- update_times: Series or 1-D np.ndarray, default None\n- New times to continue calculating the\n- exponentially weighted mean from the last values and weights.\n- If ``None``, values are assumed to be evenly spaced\n- in time.\n- This feature is currently unsupported.\n-\n- Returns\n- -------\n- DataFrame or Series\n-\n- Examples\n- --------\n- >>> df = pd.DataFrame({\"a\": range(5), \"b\": range(5, 10)})\n- >>> online_ewm = df.head(2).ewm(0.5).online()\n- >>> online_ewm.mean()\n- a b\n- 0 0.00 5.00\n- 1 0.75 5.75\n- >>> online_ewm.mean(update=df.tail(3))\n- a b\n- 2 1.615385 6.615385\n- 3 2.550000 7.550000\n- 4 3.520661 8.520661\n- >>> online_ewm.reset()\n- >>> online_ewm.mean()\n- a b\n- 0 0.00 5.00\n- 1 0.75 5.75\n- \"\"\"\n- result_kwargs = {}\n- is_frame = True if self._selected_obj.ndim == 2 else False\n- if update_times is not None:\n- raise NotImplementedError(\"update_times is not implemented.\")\n- else:\n- update_deltas = np.ones(\n- max(self._selected_obj.shape[self.axis - 1] - 1, 0), dtype=np.float64\n- )\n- if update is not None:\n- if self._mean.last_ewm is None:\n- raise ValueError(\n- \"Must call mean with update=None first before passing update\"\n- )\n- result_from = 1\n- result_kwargs[\"index\"] = update.index\n- if is_frame:\n- last_value = self._mean.last_ewm[np.newaxis, :]\n- result_kwargs[\"columns\"] = update.columns\n- else:\n- last_value = self._mean.last_ewm\n- result_kwargs[\"name\"] = update.name\n- np_array = np.concatenate((last_value, update.to_numpy()))\n- else:\n- result_from = 0\n- result_kwargs[\"index\"] = self._selected_obj.index\n- if is_frame:\n- result_kwargs[\"columns\"] = self._selected_obj.columns\n- else:\n- result_kwargs[\"name\"] = self._selected_obj.name\n- np_array = self._selected_obj.astype(np.float64).to_numpy()\n- ewma_func = generate_online_numba_ewma_func(\n- **get_jit_arguments(self.engine_kwargs)\n- )\n- result = self._mean.run_ewm(\n- np_array if is_frame else np_array[:, np.newaxis],\n- update_deltas,\n- self.min_periods,\n- ewma_func,\n- )\n- if not is_frame:\n- result = result.squeeze()\n- result = result[result_from:]\n- result = self._selected_obj._constructor(result, **result_kwargs)\n- return result\n+from pandas._core.window.ewm import *\ndiff --git a/pandas/core/window/expanding.py b/pandas/core/window/expanding.py\nindex d1a8b70b34462..8ee9a2e1665de 100644\n--- a/pandas/core/window/expanding.py\n+++ b/pandas/core/window/expanding.py\n@@ -1,882 +1 @@\n-from __future__ import annotations\n-\n-from textwrap import dedent\n-from typing import (\n- TYPE_CHECKING,\n- Any,\n- Callable,\n-)\n-\n-from pandas._typing import (\n- Axis,\n- WindowingRankType,\n-)\n-\n-if TYPE_CHECKING:\n- from pandas import DataFrame, Series\n- from pandas.core.generic import NDFrame\n-\n-from pandas.compat.numpy import function as nv\n-from pandas.util._decorators import doc\n-\n-from pandas.core.indexers.objects import (\n- BaseIndexer,\n- ExpandingIndexer,\n- GroupbyIndexer,\n-)\n-from pandas.core.window.doc import (\n- _shared_docs,\n- args_compat,\n- create_section_header,\n- kwargs_compat,\n- kwargs_numeric_only,\n- numba_notes,\n- template_header,\n- template_returns,\n- template_see_also,\n- window_agg_numba_parameters,\n- window_apply_parameters,\n-)\n-from pandas.core.window.rolling import (\n- BaseWindowGroupby,\n- RollingAndExpandingMixin,\n-)\n-\n-\n-class Expanding(RollingAndExpandingMixin):\n- \"\"\"\n- Provide expanding window calculations.\n-\n- Parameters\n- ----------\n- min_periods : int, default 1\n- Minimum number of observations in window required to have a value;\n- otherwise, result is ``np.nan``.\n-\n- center : bool, default False\n- If False, set the window labels as the right edge of the window index.\n-\n- If True, set the window labels as the center of the window index.\n-\n- .. deprecated:: 1.1.0\n-\n- axis : int or str, default 0\n- If ``0`` or ``'index'``, roll across the rows.\n-\n- If ``1`` or ``'columns'``, roll across the columns.\n-\n- For `Series` this parameter is unused and defaults to 0.\n-\n- method : str {'single', 'table'}, default 'single'\n- Execute the rolling operation per single column or row (``'single'``)\n- or over the entire object (``'table'``).\n-\n- This argument is only implemented when specifying ``engine='numba'``\n- in the method call.\n-\n- .. versionadded:: 1.3.0\n-\n- Returns\n- -------\n- ``Expanding`` subclass\n-\n- See Also\n- --------\n- rolling : Provides rolling window calculations.\n- ewm : Provides exponential weighted functions.\n-\n- Notes\n- -----\n- See :ref:`Windowing Operations <window.expanding>` for further usage details\n- and examples.\n-\n- Examples\n- --------\n- >>> df = pd.DataFrame({\"B\": [0, 1, 2, np.nan, 4]})\n- >>> df\n- B\n- 0 0.0\n- 1 1.0\n- 2 2.0\n- 3 NaN\n- 4 4.0\n-\n- **min_periods**\n-\n- Expanding sum with 1 vs 3 observations needed to calculate a value.\n-\n- >>> df.expanding(1).sum()\n- B\n- 0 0.0\n- 1 1.0\n- 2 3.0\n- 3 3.0\n- 4 7.0\n- >>> df.expanding(3).sum()\n- B\n- 0 NaN\n- 1 NaN\n- 2 3.0\n- 3 3.0\n- 4 7.0\n- \"\"\"\n-\n- _attributes: list[str] = [\"min_periods\", \"center\", \"axis\", \"method\"]\n-\n- def __init__(\n- self,\n- obj: NDFrame,\n- min_periods: int = 1,\n- center: bool | None = None,\n- axis: Axis = 0,\n- method: str = \"single\",\n- selection=None,\n- ) -> None:\n- super().__init__(\n- obj=obj,\n- min_periods=min_periods,\n- center=center,\n- axis=axis,\n- method=method,\n- selection=selection,\n- )\n-\n- def _get_window_indexer(self) -> BaseIndexer:\n- \"\"\"\n- Return an indexer class that will compute the window start and end bounds\n- \"\"\"\n- return ExpandingIndexer()\n-\n- @doc(\n- _shared_docs[\"aggregate\"],\n- see_also=dedent(\n- \"\"\"\n- See Also\n- --------\n- pandas.DataFrame.aggregate : Similar DataFrame method.\n- pandas.Series.aggregate : Similar Series method.\n- \"\"\"\n- ),\n- examples=dedent(\n- \"\"\"\n- Examples\n- --------\n- >>> df = pd.DataFrame({\"A\": [1, 2, 3], \"B\": [4, 5, 6], \"C\": [7, 8, 9]})\n- >>> df\n- A B C\n- 0 1 4 7\n- 1 2 5 8\n- 2 3 6 9\n-\n- >>> df.ewm(alpha=0.5).mean()\n- A B C\n- 0 1.000000 4.000000 7.000000\n- 1 1.666667 4.666667 7.666667\n- 2 2.428571 5.428571 8.428571\n- \"\"\"\n- ),\n- klass=\"Series/Dataframe\",\n- axis=\"\",\n- )\n- def aggregate(self, func, *args, **kwargs):\n- return super().aggregate(func, *args, **kwargs)\n-\n- agg = aggregate\n-\n- @doc(\n- template_header,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also[:-1],\n- window_method=\"expanding\",\n- aggregation_description=\"count of non NaN observations\",\n- agg_method=\"count\",\n- )\n- def count(self, numeric_only: bool = False):\n- return super().count(numeric_only=numeric_only)\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- window_apply_parameters,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also[:-1],\n- window_method=\"expanding\",\n- aggregation_description=\"custom aggregation function\",\n- agg_method=\"apply\",\n- )\n- def apply(\n- self,\n- func: Callable[..., Any],\n- raw: bool = False,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- args: tuple[Any, ...] | None = None,\n- kwargs: dict[str, Any] | None = None,\n- ):\n- return super().apply(\n- func,\n- raw=raw,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- args=args,\n- kwargs=kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- args_compat,\n- window_agg_numba_parameters(),\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also,\n- create_section_header(\"Notes\"),\n- numba_notes[:-1],\n- window_method=\"expanding\",\n- aggregation_description=\"sum\",\n- agg_method=\"sum\",\n- )\n- def sum(\n- self,\n- numeric_only: bool = False,\n- *args,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- nv.validate_expanding_func(\"sum\", args, kwargs)\n- return super().sum(\n- numeric_only=numeric_only,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- args_compat,\n- window_agg_numba_parameters(),\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also,\n- create_section_header(\"Notes\"),\n- numba_notes[:-1],\n- window_method=\"expanding\",\n- aggregation_description=\"maximum\",\n- agg_method=\"max\",\n- )\n- def max(\n- self,\n- numeric_only: bool = False,\n- *args,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- nv.validate_expanding_func(\"max\", args, kwargs)\n- return super().max(\n- numeric_only=numeric_only,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- args_compat,\n- window_agg_numba_parameters(),\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also,\n- create_section_header(\"Notes\"),\n- numba_notes[:-1],\n- window_method=\"expanding\",\n- aggregation_description=\"minimum\",\n- agg_method=\"min\",\n- )\n- def min(\n- self,\n- numeric_only: bool = False,\n- *args,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- nv.validate_expanding_func(\"min\", args, kwargs)\n- return super().min(\n- numeric_only=numeric_only,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- args_compat,\n- window_agg_numba_parameters(),\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also,\n- create_section_header(\"Notes\"),\n- numba_notes[:-1],\n- window_method=\"expanding\",\n- aggregation_description=\"mean\",\n- agg_method=\"mean\",\n- )\n- def mean(\n- self,\n- numeric_only: bool = False,\n- *args,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- nv.validate_expanding_func(\"mean\", args, kwargs)\n- return super().mean(\n- numeric_only=numeric_only,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- window_agg_numba_parameters(),\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also,\n- create_section_header(\"Notes\"),\n- numba_notes[:-1],\n- window_method=\"expanding\",\n- aggregation_description=\"median\",\n- agg_method=\"median\",\n- )\n- def median(\n- self,\n- numeric_only: bool = False,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- return super().median(\n- numeric_only=numeric_only,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- dedent(\n- \"\"\"\n- ddof : int, default 1\n- Delta Degrees of Freedom. The divisor used in calculations\n- is ``N - ddof``, where ``N`` represents the number of elements.\\n\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- kwargs_numeric_only,\n- args_compat,\n- window_agg_numba_parameters(\"1.4\"),\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- \"numpy.std : Equivalent method for NumPy array.\\n\",\n- template_see_also,\n- create_section_header(\"Notes\"),\n- dedent(\n- \"\"\"\n- The default ``ddof`` of 1 used in :meth:`Series.std` is different\n- than the default ``ddof`` of 0 in :func:`numpy.std`.\n-\n- A minimum of one period is required for the rolling calculation.\\n\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- create_section_header(\"Examples\"),\n- dedent(\n- \"\"\"\n- >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])\n-\n- >>> s.expanding(3).std()\n- 0 NaN\n- 1 NaN\n- 2 0.577350\n- 3 0.957427\n- 4 0.894427\n- 5 0.836660\n- 6 0.786796\n- dtype: float64\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- window_method=\"expanding\",\n- aggregation_description=\"standard deviation\",\n- agg_method=\"std\",\n- )\n- def std(\n- self,\n- ddof: int = 1,\n- numeric_only: bool = False,\n- *args,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- nv.validate_expanding_func(\"std\", args, kwargs)\n- return super().std(\n- ddof=ddof,\n- numeric_only=numeric_only,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- dedent(\n- \"\"\"\n- ddof : int, default 1\n- Delta Degrees of Freedom. The divisor used in calculations\n- is ``N - ddof``, where ``N`` represents the number of elements.\\n\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- kwargs_numeric_only,\n- args_compat,\n- window_agg_numba_parameters(\"1.4\"),\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- \"numpy.var : Equivalent method for NumPy array.\\n\",\n- template_see_also,\n- create_section_header(\"Notes\"),\n- dedent(\n- \"\"\"\n- The default ``ddof`` of 1 used in :meth:`Series.var` is different\n- than the default ``ddof`` of 0 in :func:`numpy.var`.\n-\n- A minimum of one period is required for the rolling calculation.\\n\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- create_section_header(\"Examples\"),\n- dedent(\n- \"\"\"\n- >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])\n-\n- >>> s.expanding(3).var()\n- 0 NaN\n- 1 NaN\n- 2 0.333333\n- 3 0.916667\n- 4 0.800000\n- 5 0.700000\n- 6 0.619048\n- dtype: float64\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- window_method=\"expanding\",\n- aggregation_description=\"variance\",\n- agg_method=\"var\",\n- )\n- def var(\n- self,\n- ddof: int = 1,\n- numeric_only: bool = False,\n- *args,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- nv.validate_expanding_func(\"var\", args, kwargs)\n- return super().var(\n- ddof=ddof,\n- numeric_only=numeric_only,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- dedent(\n- \"\"\"\n- ddof : int, default 1\n- Delta Degrees of Freedom. The divisor used in calculations\n- is ``N - ddof``, where ``N`` represents the number of elements.\\n\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- kwargs_numeric_only,\n- args_compat,\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also,\n- create_section_header(\"Notes\"),\n- \"A minimum of one period is required for the calculation.\\n\\n\",\n- create_section_header(\"Examples\"),\n- dedent(\n- \"\"\"\n- >>> s = pd.Series([0, 1, 2, 3])\n-\n- >>> s.expanding().sem()\n- 0 NaN\n- 1 0.707107\n- 2 0.707107\n- 3 0.745356\n- dtype: float64\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- window_method=\"expanding\",\n- aggregation_description=\"standard error of mean\",\n- agg_method=\"sem\",\n- )\n- def sem(self, ddof: int = 1, *args, **kwargs):\n- return super().sem(ddof=ddof, **kwargs)\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- \"scipy.stats.skew : Third moment of a probability density.\\n\",\n- template_see_also,\n- create_section_header(\"Notes\"),\n- \"A minimum of three periods is required for the rolling calculation.\\n\",\n- window_method=\"expanding\",\n- aggregation_description=\"unbiased skewness\",\n- agg_method=\"skew\",\n- )\n- def skew(self, numeric_only: bool = False, **kwargs):\n- return super().skew(numeric_only=numeric_only, **kwargs)\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- \"scipy.stats.kurtosis : Reference SciPy method.\\n\",\n- template_see_also,\n- create_section_header(\"Notes\"),\n- \"A minimum of four periods is required for the calculation.\\n\\n\",\n- create_section_header(\"Examples\"),\n- dedent(\n- \"\"\"\n- The example below will show a rolling calculation with a window size of\n- four matching the equivalent function call using `scipy.stats`.\n-\n- >>> arr = [1, 2, 3, 4, 999]\n- >>> import scipy.stats\n- >>> print(f\"{{scipy.stats.kurtosis(arr[:-1], bias=False):.6f}}\")\n- -1.200000\n- >>> print(f\"{{scipy.stats.kurtosis(arr, bias=False):.6f}}\")\n- 4.999874\n- >>> s = pd.Series(arr)\n- >>> s.expanding(4).kurt()\n- 0 NaN\n- 1 NaN\n- 2 NaN\n- 3 -1.200000\n- 4 4.999874\n- dtype: float64\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- window_method=\"expanding\",\n- aggregation_description=\"Fisher's definition of kurtosis without bias\",\n- agg_method=\"kurt\",\n- )\n- def kurt(self, numeric_only: bool = False, **kwargs):\n- return super().kurt(numeric_only=numeric_only, **kwargs)\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- dedent(\n- \"\"\"\n- quantile : float\n- Quantile to compute. 0 <= quantile <= 1.\n- interpolation : {{'linear', 'lower', 'higher', 'midpoint', 'nearest'}}\n- This optional parameter specifies the interpolation method to use,\n- when the desired quantile lies between two data points `i` and `j`:\n-\n- * linear: `i + (j - i) * fraction`, where `fraction` is the\n- fractional part of the index surrounded by `i` and `j`.\n- * lower: `i`.\n- * higher: `j`.\n- * nearest: `i` or `j` whichever is nearest.\n- * midpoint: (`i` + `j`) / 2.\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- kwargs_numeric_only,\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also[:-1],\n- window_method=\"expanding\",\n- aggregation_description=\"quantile\",\n- agg_method=\"quantile\",\n- )\n- def quantile(\n- self,\n- quantile: float,\n- interpolation: str = \"linear\",\n- numeric_only: bool = False,\n- **kwargs,\n- ):\n- return super().quantile(\n- quantile=quantile,\n- interpolation=interpolation,\n- numeric_only=numeric_only,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- \".. versionadded:: 1.4.0 \\n\\n\",\n- create_section_header(\"Parameters\"),\n- dedent(\n- \"\"\"\n- method : {{'average', 'min', 'max'}}, default 'average'\n- How to rank the group of records that have the same value (i.e. ties):\n-\n- * average: average rank of the group\n- * min: lowest rank in the group\n- * max: highest rank in the group\n-\n- ascending : bool, default True\n- Whether or not the elements should be ranked in ascending order.\n- pct : bool, default False\n- Whether or not to display the returned rankings in percentile\n- form.\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- kwargs_numeric_only,\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also,\n- create_section_header(\"Examples\"),\n- dedent(\n- \"\"\"\n- >>> s = pd.Series([1, 4, 2, 3, 5, 3])\n- >>> s.expanding().rank()\n- 0 1.0\n- 1 2.0\n- 2 2.0\n- 3 3.0\n- 4 5.0\n- 5 3.5\n- dtype: float64\n-\n- >>> s.expanding().rank(method=\"max\")\n- 0 1.0\n- 1 2.0\n- 2 2.0\n- 3 3.0\n- 4 5.0\n- 5 4.0\n- dtype: float64\n-\n- >>> s.expanding().rank(method=\"min\")\n- 0 1.0\n- 1 2.0\n- 2 2.0\n- 3 3.0\n- 4 5.0\n- 5 3.0\n- dtype: float64\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- window_method=\"expanding\",\n- aggregation_description=\"rank\",\n- agg_method=\"rank\",\n- )\n- def rank(\n- self,\n- method: WindowingRankType = \"average\",\n- ascending: bool = True,\n- pct: bool = False,\n- numeric_only: bool = False,\n- **kwargs,\n- ):\n- return super().rank(\n- method=method,\n- ascending=ascending,\n- pct=pct,\n- numeric_only=numeric_only,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- dedent(\n- \"\"\"\n- other : Series or DataFrame, optional\n- If not supplied then will default to self and produce pairwise\n- output.\n- pairwise : bool, default None\n- If False then only matching columns between self and other will be\n- used and the output will be a DataFrame.\n- If True then all pairwise combinations will be calculated and the\n- output will be a MultiIndexed DataFrame in the case of DataFrame\n- inputs. In the case of missing elements, only complete pairwise\n- observations will be used.\n- ddof : int, default 1\n- Delta Degrees of Freedom. The divisor used in calculations\n- is ``N - ddof``, where ``N`` represents the number of elements.\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- kwargs_numeric_only,\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also[:-1],\n- window_method=\"expanding\",\n- aggregation_description=\"sample covariance\",\n- agg_method=\"cov\",\n- )\n- def cov(\n- self,\n- other: DataFrame | Series | None = None,\n- pairwise: bool | None = None,\n- ddof: int = 1,\n- numeric_only: bool = False,\n- **kwargs,\n- ):\n- return super().cov(\n- other=other,\n- pairwise=pairwise,\n- ddof=ddof,\n- numeric_only=numeric_only,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- dedent(\n- \"\"\"\n- other : Series or DataFrame, optional\n- If not supplied then will default to self and produce pairwise\n- output.\n- pairwise : bool, default None\n- If False then only matching columns between self and other will be\n- used and the output will be a DataFrame.\n- If True then all pairwise combinations will be calculated and the\n- output will be a MultiIndexed DataFrame in the case of DataFrame\n- inputs. In the case of missing elements, only complete pairwise\n- observations will be used.\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- kwargs_numeric_only,\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- dedent(\n- \"\"\"\n- cov : Similar method to calculate covariance.\n- numpy.corrcoef : NumPy Pearson's correlation calculation.\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- template_see_also,\n- create_section_header(\"Notes\"),\n- dedent(\n- \"\"\"\n- This function uses Pearson's definition of correlation\n- (https://en.wikipedia.org/wiki/Pearson_correlation_coefficient).\n-\n- When `other` is not specified, the output will be self correlation (e.g.\n- all 1's), except for :class:`~pandas.DataFrame` inputs with `pairwise`\n- set to `True`.\n-\n- Function will return ``NaN`` for correlations of equal valued sequences;\n- this is the result of a 0/0 division error.\n-\n- When `pairwise` is set to `False`, only matching columns between `self` and\n- `other` will be used.\n-\n- When `pairwise` is set to `True`, the output will be a MultiIndex DataFrame\n- with the original index on the first level, and the `other` DataFrame\n- columns on the second level.\n-\n- In the case of missing elements, only complete pairwise observations\n- will be used.\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- window_method=\"expanding\",\n- aggregation_description=\"correlation\",\n- agg_method=\"corr\",\n- )\n- def corr(\n- self,\n- other: DataFrame | Series | None = None,\n- pairwise: bool | None = None,\n- ddof: int = 1,\n- numeric_only: bool = False,\n- **kwargs,\n- ):\n- return super().corr(\n- other=other,\n- pairwise=pairwise,\n- ddof=ddof,\n- numeric_only=numeric_only,\n- **kwargs,\n- )\n-\n-\n-class ExpandingGroupby(BaseWindowGroupby, Expanding):\n- \"\"\"\n- Provide a expanding groupby implementation.\n- \"\"\"\n-\n- _attributes = Expanding._attributes + BaseWindowGroupby._attributes\n-\n- def _get_window_indexer(self) -> GroupbyIndexer:\n- \"\"\"\n- Return an indexer class that will compute the window start and end bounds\n-\n- Returns\n- -------\n- GroupbyIndexer\n- \"\"\"\n- window_indexer = GroupbyIndexer(\n- groupby_indices=self._grouper.indices,\n- window_indexer=ExpandingIndexer,\n- )\n- return window_indexer\n+from pandas._core.window.expanding import *\ndiff --git a/pandas/core/window/numba_.py b/pandas/core/window/numba_.py\nindex 0f9f01e93a477..1e1d15d8f7340 100644\n--- a/pandas/core/window/numba_.py\n+++ b/pandas/core/window/numba_.py\n@@ -1,350 +1 @@\n-from __future__ import annotations\n-\n-import functools\n-from typing import (\n- TYPE_CHECKING,\n- Any,\n- Callable,\n-)\n-\n-import numpy as np\n-\n-from pandas._typing import Scalar\n-from pandas.compat._optional import import_optional_dependency\n-\n-from pandas.core.util.numba_ import jit_user_function\n-\n-\n-@functools.lru_cache(maxsize=None)\n-def generate_numba_apply_func(\n- func: Callable[..., Scalar],\n- nopython: bool,\n- nogil: bool,\n- parallel: bool,\n-):\n- \"\"\"\n- Generate a numba jitted apply function specified by values from engine_kwargs.\n-\n- 1. jit the user's function\n- 2. Return a rolling apply function with the jitted function inline\n-\n- Configurations specified in engine_kwargs apply to both the user's\n- function _AND_ the rolling apply function.\n-\n- Parameters\n- ----------\n- func : function\n- function to be applied to each window and will be JITed\n- nopython : bool\n- nopython to be passed into numba.jit\n- nogil : bool\n- nogil to be passed into numba.jit\n- parallel : bool\n- parallel to be passed into numba.jit\n-\n- Returns\n- -------\n- Numba function\n- \"\"\"\n- numba_func = jit_user_function(func, nopython, nogil, parallel)\n- if TYPE_CHECKING:\n- import numba\n- else:\n- numba = import_optional_dependency(\"numba\")\n-\n- @numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)\n- def roll_apply(\n- values: np.ndarray,\n- begin: np.ndarray,\n- end: np.ndarray,\n- minimum_periods: int,\n- *args: Any,\n- ) -> np.ndarray:\n- result = np.empty(len(begin))\n- for i in numba.prange(len(result)):\n- start = begin[i]\n- stop = end[i]\n- window = values[start:stop]\n- count_nan = np.sum(np.isnan(window))\n- if len(window) - count_nan >= minimum_periods:\n- result[i] = numba_func(window, *args)\n- else:\n- result[i] = np.nan\n- return result\n-\n- return roll_apply\n-\n-\n-@functools.lru_cache(maxsize=None)\n-def generate_numba_ewm_func(\n- nopython: bool,\n- nogil: bool,\n- parallel: bool,\n- com: float,\n- adjust: bool,\n- ignore_na: bool,\n- deltas: tuple,\n- normalize: bool,\n-):\n- \"\"\"\n- Generate a numba jitted ewm mean or sum function specified by values\n- from engine_kwargs.\n-\n- Parameters\n- ----------\n- nopython : bool\n- nopython to be passed into numba.jit\n- nogil : bool\n- nogil to be passed into numba.jit\n- parallel : bool\n- parallel to be passed into numba.jit\n- com : float\n- adjust : bool\n- ignore_na : bool\n- deltas : tuple\n- normalize : bool\n-\n- Returns\n- -------\n- Numba function\n- \"\"\"\n- if TYPE_CHECKING:\n- import numba\n- else:\n- numba = import_optional_dependency(\"numba\")\n-\n- @numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)\n- def ewm(\n- values: np.ndarray,\n- begin: np.ndarray,\n- end: np.ndarray,\n- minimum_periods: int,\n- ) -> np.ndarray:\n- result = np.empty(len(values))\n- alpha = 1.0 / (1.0 + com)\n- old_wt_factor = 1.0 - alpha\n- new_wt = 1.0 if adjust else alpha\n-\n- for i in numba.prange(len(begin)):\n- start = begin[i]\n- stop = end[i]\n- window = values[start:stop]\n- sub_result = np.empty(len(window))\n-\n- weighted = window[0]\n- nobs = int(not np.isnan(weighted))\n- sub_result[0] = weighted if nobs >= minimum_periods else np.nan\n- old_wt = 1.0\n-\n- for j in range(1, len(window)):\n- cur = window[j]\n- is_observation = not np.isnan(cur)\n- nobs += is_observation\n- if not np.isnan(weighted):\n-\n- if is_observation or not ignore_na:\n- if normalize:\n- # note that len(deltas) = len(vals) - 1 and deltas[i]\n- # is to be used in conjunction with vals[i+1]\n- old_wt *= old_wt_factor ** deltas[start + j - 1]\n- else:\n- weighted = old_wt_factor * weighted\n- if is_observation:\n- if normalize:\n- # avoid numerical errors on constant series\n- if weighted != cur:\n- weighted = old_wt * weighted + new_wt * cur\n- if normalize:\n- weighted = weighted / (old_wt + new_wt)\n- if adjust:\n- old_wt += new_wt\n- else:\n- old_wt = 1.0\n- else:\n- weighted += cur\n- elif is_observation:\n- weighted = cur\n-\n- sub_result[j] = weighted if nobs >= minimum_periods else np.nan\n-\n- result[start:stop] = sub_result\n-\n- return result\n-\n- return ewm\n-\n-\n-@functools.lru_cache(maxsize=None)\n-def generate_numba_table_func(\n- func: Callable[..., np.ndarray],\n- nopython: bool,\n- nogil: bool,\n- parallel: bool,\n-):\n- \"\"\"\n- Generate a numba jitted function to apply window calculations table-wise.\n-\n- Func will be passed a M window size x N number of columns array, and\n- must return a 1 x N number of columns array. Func is intended to operate\n- row-wise, but the result will be transposed for axis=1.\n-\n- 1. jit the user's function\n- 2. Return a rolling apply function with the jitted function inline\n-\n- Parameters\n- ----------\n- func : function\n- function to be applied to each window and will be JITed\n- nopython : bool\n- nopython to be passed into numba.jit\n- nogil : bool\n- nogil to be passed into numba.jit\n- parallel : bool\n- parallel to be passed into numba.jit\n-\n- Returns\n- -------\n- Numba function\n- \"\"\"\n- numba_func = jit_user_function(func, nopython, nogil, parallel)\n- if TYPE_CHECKING:\n- import numba\n- else:\n- numba = import_optional_dependency(\"numba\")\n-\n- @numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)\n- def roll_table(\n- values: np.ndarray,\n- begin: np.ndarray,\n- end: np.ndarray,\n- minimum_periods: int,\n- *args: Any,\n- ):\n- result = np.empty((len(begin), values.shape[1]))\n- min_periods_mask = np.empty(result.shape)\n- for i in numba.prange(len(result)):\n- start = begin[i]\n- stop = end[i]\n- window = values[start:stop]\n- count_nan = np.sum(np.isnan(window), axis=0)\n- sub_result = numba_func(window, *args)\n- nan_mask = len(window) - count_nan >= minimum_periods\n- min_periods_mask[i, :] = nan_mask\n- result[i, :] = sub_result\n- result = np.where(min_periods_mask, result, np.nan)\n- return result\n-\n- return roll_table\n-\n-\n-# This function will no longer be needed once numba supports\n-# axis for all np.nan* agg functions\n-# https://github.com/numba/numba/issues/1269\n-@functools.lru_cache(maxsize=None)\n-def generate_manual_numpy_nan_agg_with_axis(nan_func):\n- if TYPE_CHECKING:\n- import numba\n- else:\n- numba = import_optional_dependency(\"numba\")\n-\n- @numba.jit(nopython=True, nogil=True, parallel=True)\n- def nan_agg_with_axis(table):\n- result = np.empty(table.shape[1])\n- for i in numba.prange(table.shape[1]):\n- partition = table[:, i]\n- result[i] = nan_func(partition)\n- return result\n-\n- return nan_agg_with_axis\n-\n-\n-@functools.lru_cache(maxsize=None)\n-def generate_numba_ewm_table_func(\n- nopython: bool,\n- nogil: bool,\n- parallel: bool,\n- com: float,\n- adjust: bool,\n- ignore_na: bool,\n- deltas: tuple,\n- normalize: bool,\n-):\n- \"\"\"\n- Generate a numba jitted ewm mean or sum function applied table wise specified\n- by values from engine_kwargs.\n-\n- Parameters\n- ----------\n- nopython : bool\n- nopython to be passed into numba.jit\n- nogil : bool\n- nogil to be passed into numba.jit\n- parallel : bool\n- parallel to be passed into numba.jit\n- com : float\n- adjust : bool\n- ignore_na : bool\n- deltas : tuple\n- normalize: bool\n-\n- Returns\n- -------\n- Numba function\n- \"\"\"\n- if TYPE_CHECKING:\n- import numba\n- else:\n- numba = import_optional_dependency(\"numba\")\n-\n- @numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)\n- def ewm_table(\n- values: np.ndarray,\n- begin: np.ndarray,\n- end: np.ndarray,\n- minimum_periods: int,\n- ) -> np.ndarray:\n- alpha = 1.0 / (1.0 + com)\n- old_wt_factor = 1.0 - alpha\n- new_wt = 1.0 if adjust else alpha\n- old_wt = np.ones(values.shape[1])\n-\n- result = np.empty(values.shape)\n- weighted = values[0].copy()\n- nobs = (~np.isnan(weighted)).astype(np.int64)\n- result[0] = np.where(nobs >= minimum_periods, weighted, np.nan)\n- for i in range(1, len(values)):\n- cur = values[i]\n- is_observations = ~np.isnan(cur)\n- nobs += is_observations.astype(np.int64)\n- for j in numba.prange(len(cur)):\n- if not np.isnan(weighted[j]):\n- if is_observations[j] or not ignore_na:\n- if normalize:\n- # note that len(deltas) = len(vals) - 1 and deltas[i]\n- # is to be used in conjunction with vals[i+1]\n- old_wt[j] *= old_wt_factor ** deltas[i - 1]\n- else:\n- weighted[j] = old_wt_factor * weighted[j]\n- if is_observations[j]:\n- if normalize:\n- # avoid numerical errors on constant series\n- if weighted[j] != cur[j]:\n- weighted[j] = (\n- old_wt[j] * weighted[j] + new_wt * cur[j]\n- )\n- if normalize:\n- weighted[j] = weighted[j] / (old_wt[j] + new_wt)\n- if adjust:\n- old_wt[j] += new_wt\n- else:\n- old_wt[j] = 1.0\n- else:\n- weighted[j] += cur[j]\n- elif is_observations[j]:\n- weighted[j] = cur[j]\n-\n- result[i] = np.where(nobs >= minimum_periods, weighted, np.nan)\n-\n- return result\n-\n- return ewm_table\n+from pandas._core.window.numba_ import *\ndiff --git a/pandas/core/window/online.py b/pandas/core/window/online.py\nindex 2ef06732f9800..745ba490fe239 100644\n--- a/pandas/core/window/online.py\n+++ b/pandas/core/window/online.py\n@@ -1,117 +1 @@\n-from typing import TYPE_CHECKING\n-\n-import numpy as np\n-\n-from pandas.compat._optional import import_optional_dependency\n-\n-\n-def generate_online_numba_ewma_func(\n- nopython: bool,\n- nogil: bool,\n- parallel: bool,\n-):\n- \"\"\"\n- Generate a numba jitted groupby ewma function specified by values\n- from engine_kwargs.\n-\n- Parameters\n- ----------\n- nopython : bool\n- nopython to be passed into numba.jit\n- nogil : bool\n- nogil to be passed into numba.jit\n- parallel : bool\n- parallel to be passed into numba.jit\n-\n- Returns\n- -------\n- Numba function\n- \"\"\"\n- if TYPE_CHECKING:\n- import numba\n- else:\n- numba = import_optional_dependency(\"numba\")\n-\n- @numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)\n- def online_ewma(\n- values: np.ndarray,\n- deltas: np.ndarray,\n- minimum_periods: int,\n- old_wt_factor: float,\n- new_wt: float,\n- old_wt: np.ndarray,\n- adjust: bool,\n- ignore_na: bool,\n- ):\n- \"\"\"\n- Compute online exponentially weighted mean per column over 2D values.\n-\n- Takes the first observation as is, then computes the subsequent\n- exponentially weighted mean accounting minimum periods.\n- \"\"\"\n- result = np.empty(values.shape)\n- weighted_avg = values[0]\n- nobs = (~np.isnan(weighted_avg)).astype(np.int64)\n- result[0] = np.where(nobs >= minimum_periods, weighted_avg, np.nan)\n-\n- for i in range(1, len(values)):\n- cur = values[i]\n- is_observations = ~np.isnan(cur)\n- nobs += is_observations.astype(np.int64)\n- for j in numba.prange(len(cur)):\n- if not np.isnan(weighted_avg[j]):\n- if is_observations[j] or not ignore_na:\n-\n- # note that len(deltas) = len(vals) - 1 and deltas[i] is to be\n- # used in conjunction with vals[i+1]\n- old_wt[j] *= old_wt_factor ** deltas[j - 1]\n- if is_observations[j]:\n- # avoid numerical errors on constant series\n- if weighted_avg[j] != cur[j]:\n- weighted_avg[j] = (\n- (old_wt[j] * weighted_avg[j]) + (new_wt * cur[j])\n- ) / (old_wt[j] + new_wt)\n- if adjust:\n- old_wt[j] += new_wt\n- else:\n- old_wt[j] = 1.0\n- elif is_observations[j]:\n- weighted_avg[j] = cur[j]\n-\n- result[i] = np.where(nobs >= minimum_periods, weighted_avg, np.nan)\n-\n- return result, old_wt\n-\n- return online_ewma\n-\n-\n-class EWMMeanState:\n- def __init__(self, com, adjust, ignore_na, axis, shape) -> None:\n- alpha = 1.0 / (1.0 + com)\n- self.axis = axis\n- self.shape = shape\n- self.adjust = adjust\n- self.ignore_na = ignore_na\n- self.new_wt = 1.0 if adjust else alpha\n- self.old_wt_factor = 1.0 - alpha\n- self.old_wt = np.ones(self.shape[self.axis - 1])\n- self.last_ewm = None\n-\n- def run_ewm(self, weighted_avg, deltas, min_periods, ewm_func):\n- result, old_wt = ewm_func(\n- weighted_avg,\n- deltas,\n- min_periods,\n- self.old_wt_factor,\n- self.new_wt,\n- self.old_wt,\n- self.adjust,\n- self.ignore_na,\n- )\n- self.old_wt = old_wt\n- self.last_ewm = result[-1]\n- return result\n-\n- def reset(self):\n- self.old_wt = np.ones(self.shape[self.axis - 1])\n- self.last_ewm = None\n+from pandas._core.window.online import *\ndiff --git a/pandas/core/window/rolling.py b/pandas/core/window/rolling.py\nindex b45f43adbe952..5d5700ee70caa 100644\n--- a/pandas/core/window/rolling.py\n+++ b/pandas/core/window/rolling.py\n@@ -1,2884 +1 @@\n-\"\"\"\n-Provide a generic structure to support window functions,\n-similar to how we have a Groupby object.\n-\"\"\"\n-from __future__ import annotations\n-\n-import copy\n-from datetime import timedelta\n-from functools import partial\n-import inspect\n-from textwrap import dedent\n-from typing import (\n- TYPE_CHECKING,\n- Any,\n- Callable,\n- Hashable,\n- Sized,\n-)\n-import warnings\n-\n-import numpy as np\n-\n-from pandas._libs.tslibs import (\n- BaseOffset,\n- to_offset,\n-)\n-import pandas._libs.window.aggregations as window_aggregations\n-from pandas._typing import (\n- ArrayLike,\n- Axis,\n- NDFrameT,\n- WindowingRankType,\n-)\n-from pandas.compat._optional import import_optional_dependency\n-from pandas.compat.numpy import function as nv\n-from pandas.errors import DataError\n-from pandas.util._decorators import doc\n-from pandas.util._exceptions import find_stack_level\n-\n-from pandas.core.dtypes.common import (\n- ensure_float64,\n- is_bool,\n- is_integer,\n- is_list_like,\n- is_numeric_dtype,\n- is_scalar,\n- needs_i8_conversion,\n-)\n-from pandas.core.dtypes.generic import (\n- ABCDataFrame,\n- ABCSeries,\n-)\n-from pandas.core.dtypes.missing import notna\n-\n-from pandas.core._numba import executor\n-from pandas.core.algorithms import factorize\n-from pandas.core.apply import ResamplerWindowApply\n-from pandas.core.arrays import ExtensionArray\n-from pandas.core.base import SelectionMixin\n-import pandas.core.common as com\n-from pandas.core.indexers.objects import (\n- BaseIndexer,\n- FixedWindowIndexer,\n- GroupbyIndexer,\n- VariableWindowIndexer,\n-)\n-from pandas.core.indexes.api import (\n- DatetimeIndex,\n- Index,\n- MultiIndex,\n- PeriodIndex,\n- TimedeltaIndex,\n-)\n-from pandas.core.reshape.concat import concat\n-from pandas.core.util.numba_ import (\n- get_jit_arguments,\n- maybe_use_numba,\n-)\n-from pandas.core.window.common import (\n- flex_binary_moment,\n- zsqrt,\n-)\n-from pandas.core.window.doc import (\n- _shared_docs,\n- args_compat,\n- create_section_header,\n- kwargs_compat,\n- kwargs_numeric_only,\n- kwargs_scipy,\n- numba_notes,\n- template_header,\n- template_returns,\n- template_see_also,\n- window_agg_numba_parameters,\n- window_apply_parameters,\n-)\n-from pandas.core.window.numba_ import (\n- generate_manual_numpy_nan_agg_with_axis,\n- generate_numba_apply_func,\n- generate_numba_table_func,\n-)\n-\n-if TYPE_CHECKING:\n- from pandas import (\n- DataFrame,\n- Series,\n- )\n- from pandas.core.generic import NDFrame\n- from pandas.core.groupby.ops import BaseGrouper\n- from pandas.core.internals import Block # noqa:F401\n-\n-\n-class BaseWindow(SelectionMixin):\n- \"\"\"Provides utilities for performing windowing operations.\"\"\"\n-\n- _attributes: list[str] = []\n- exclusions: frozenset[Hashable] = frozenset()\n- _on: Index\n-\n- def __init__(\n- self,\n- obj: NDFrame,\n- window=None,\n- min_periods: int | None = None,\n- center: bool | None = False,\n- win_type: str | None = None,\n- axis: Axis = 0,\n- on: str | Index | None = None,\n- closed: str | None = None,\n- step: int | None = None,\n- method: str = \"single\",\n- *,\n- selection=None,\n- ) -> None:\n- self.obj = obj\n- self.on = on\n- self.closed = closed\n- self.step = step\n- self.window = window\n- self.min_periods = min_periods\n- self.center = center\n- # TODO(2.0): Change this back to self.win_type once deprecation is enforced\n- self._win_type = win_type\n- self.axis = obj._get_axis_number(axis) if axis is not None else None\n- self.method = method\n- self._win_freq_i8 = None\n- if self.on is None:\n- if self.axis == 0:\n- self._on = self.obj.index\n- else:\n- # i.e. self.axis == 1\n- self._on = self.obj.columns\n- elif isinstance(self.on, Index):\n- self._on = self.on\n- elif isinstance(self.obj, ABCDataFrame) and self.on in self.obj.columns:\n- self._on = Index(self.obj[self.on])\n- else:\n- raise ValueError(\n- f\"invalid on specified as {self.on}, \"\n- \"must be a column (of DataFrame), an Index or None\"\n- )\n-\n- self._selection = selection\n- self._validate()\n-\n- @property\n- def win_type(self):\n- if self._win_freq_i8 is not None:\n- warnings.warn(\n- \"win_type will no longer return 'freq' in a future version. \"\n- \"Check the type of self.window instead.\",\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n- return \"freq\"\n- return self._win_type\n-\n- @property\n- def is_datetimelike(self) -> bool:\n- warnings.warn(\n- \"is_datetimelike is deprecated and will be removed in a future version.\",\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n- return self._win_freq_i8 is not None\n-\n- def validate(self) -> None:\n- warnings.warn(\n- \"validate is deprecated and will be removed in a future version.\",\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n- return self._validate()\n-\n- def _validate(self) -> None:\n- if self.center is not None and not is_bool(self.center):\n- raise ValueError(\"center must be a boolean\")\n- if self.min_periods is not None:\n- if not is_integer(self.min_periods):\n- raise ValueError(\"min_periods must be an integer\")\n- elif self.min_periods < 0:\n- raise ValueError(\"min_periods must be >= 0\")\n- elif is_integer(self.window) and self.min_periods > self.window:\n- raise ValueError(\n- f\"min_periods {self.min_periods} must be <= window {self.window}\"\n- )\n- if self.closed is not None and self.closed not in [\n- \"right\",\n- \"both\",\n- \"left\",\n- \"neither\",\n- ]:\n- raise ValueError(\"closed must be 'right', 'left', 'both' or 'neither'\")\n- if not isinstance(self.obj, (ABCSeries, ABCDataFrame)):\n- raise TypeError(f\"invalid type: {type(self)}\")\n- if isinstance(self.window, BaseIndexer):\n- # Validate that the passed BaseIndexer subclass has\n- # a get_window_bounds with the correct signature.\n- get_window_bounds_signature = inspect.signature(\n- self.window.get_window_bounds\n- ).parameters.keys()\n- expected_signature = inspect.signature(\n- BaseIndexer().get_window_bounds\n- ).parameters.keys()\n- if get_window_bounds_signature != expected_signature:\n- raise ValueError(\n- f\"{type(self.window).__name__} does not implement \"\n- f\"the correct signature for get_window_bounds\"\n- )\n- if self.method not in [\"table\", \"single\"]:\n- raise ValueError(\"method must be 'table' or 'single\")\n- if self.step is not None:\n- if not is_integer(self.step):\n- raise ValueError(\"step must be an integer\")\n- elif self.step < 0:\n- raise ValueError(\"step must be >= 0\")\n-\n- def _check_window_bounds(\n- self, start: np.ndarray, end: np.ndarray, num_vals: int\n- ) -> None:\n- if len(start) != len(end):\n- raise ValueError(\n- f\"start ({len(start)}) and end ({len(end)}) bounds must be the \"\n- f\"same length\"\n- )\n- elif len(start) != (num_vals + (self.step or 1) - 1) // (self.step or 1):\n- raise ValueError(\n- f\"start and end bounds ({len(start)}) must be the same length \"\n- f\"as the object ({num_vals}) divided by the step ({self.step}) \"\n- f\"if given and rounded up\"\n- )\n-\n- def _slice_axis_for_step(self, index: Index, result: Sized | None = None) -> Index:\n- \"\"\"\n- Slices the index for a given result and the preset step.\n- \"\"\"\n- return (\n- index\n- if result is None or len(result) == len(index)\n- else index[:: self.step]\n- )\n-\n- def _validate_numeric_only(self, name: str, numeric_only: bool) -> None:\n- \"\"\"\n- Validate numeric_only argument, raising if invalid for the input.\n-\n- Parameters\n- ----------\n- name : str\n- Name of the operator (kernel).\n- numeric_only : bool\n- Value passed by user.\n- \"\"\"\n- if (\n- self._selected_obj.ndim == 1\n- and numeric_only\n- and not is_numeric_dtype(self._selected_obj.dtype)\n- ):\n- raise NotImplementedError(\n- f\"{type(self).__name__}.{name} does not implement numeric_only\"\n- )\n-\n- def _make_numeric_only(self, obj: NDFrameT) -> NDFrameT:\n- \"\"\"Subset DataFrame to numeric columns.\n-\n- Parameters\n- ----------\n- obj : DataFrame\n-\n- Returns\n- -------\n- obj subset to numeric-only columns.\n- \"\"\"\n- result = obj.select_dtypes(include=[\"number\"], exclude=[\"timedelta\"])\n- return result\n-\n- def _create_data(self, obj: NDFrameT, numeric_only: bool = False) -> NDFrameT:\n- \"\"\"\n- Split data into blocks & return conformed data.\n- \"\"\"\n- # filter out the on from the object\n- if self.on is not None and not isinstance(self.on, Index) and obj.ndim == 2:\n- obj = obj.reindex(columns=obj.columns.difference([self.on]), copy=False)\n- if obj.ndim > 1 and (numeric_only or self.axis == 1):\n- # GH: 20649 in case of mixed dtype and axis=1 we have to convert everything\n- # to float to calculate the complete row at once. We exclude all non-numeric\n- # dtypes.\n- obj = self._make_numeric_only(obj)\n- if self.axis == 1:\n- obj = obj.astype(\"float64\", copy=False)\n- obj._mgr = obj._mgr.consolidate()\n- return obj\n-\n- def _gotitem(self, key, ndim, subset=None):\n- \"\"\"\n- Sub-classes to define. Return a sliced object.\n-\n- Parameters\n- ----------\n- key : str / list of selections\n- ndim : {1, 2}\n- requested ndim of result\n- subset : object, default None\n- subset to act on\n- \"\"\"\n- # create a new object to prevent aliasing\n- if subset is None:\n- subset = self.obj\n-\n- # we need to make a shallow copy of ourselves\n- # with the same groupby\n- with warnings.catch_warnings():\n- # TODO(2.0): Remove once win_type deprecation is enforced\n- warnings.filterwarnings(\"ignore\", \"win_type\", FutureWarning)\n- kwargs = {attr: getattr(self, attr) for attr in self._attributes}\n-\n- selection = None\n- if subset.ndim == 2 and (\n- (is_scalar(key) and key in subset) or is_list_like(key)\n- ):\n- selection = key\n-\n- new_win = type(self)(subset, selection=selection, **kwargs)\n- return new_win\n-\n- def __getattr__(self, attr: str):\n- if attr in self._internal_names_set:\n- return object.__getattribute__(self, attr)\n- if attr in self.obj:\n- return self[attr]\n-\n- raise AttributeError(\n- f\"'{type(self).__name__}' object has no attribute '{attr}'\"\n- )\n-\n- def _dir_additions(self):\n- return self.obj._dir_additions()\n-\n- def __repr__(self) -> str:\n- \"\"\"\n- Provide a nice str repr of our rolling object.\n- \"\"\"\n- attrs_list = (\n- f\"{attr_name}={getattr(self, attr_name)}\"\n- for attr_name in self._attributes\n- if getattr(self, attr_name, None) is not None and attr_name[0] != \"_\"\n- )\n- attrs = \",\".join(attrs_list)\n- return f\"{type(self).__name__} [{attrs}]\"\n-\n- def __iter__(self):\n- obj = self._selected_obj.set_axis(self._on)\n- obj = self._create_data(obj)\n- indexer = self._get_window_indexer()\n-\n- start, end = indexer.get_window_bounds(\n- num_values=len(obj),\n- min_periods=self.min_periods,\n- center=self.center,\n- closed=self.closed,\n- step=self.step,\n- )\n- self._check_window_bounds(start, end, len(obj))\n-\n- for s, e in zip(start, end):\n- result = obj.iloc[slice(s, e)]\n- yield result\n-\n- def _prep_values(self, values: ArrayLike) -> np.ndarray:\n- \"\"\"Convert input to numpy arrays for Cython routines\"\"\"\n- if needs_i8_conversion(values.dtype):\n- raise NotImplementedError(\n- f\"ops for {type(self).__name__} for this \"\n- f\"dtype {values.dtype} are not implemented\"\n- )\n- else:\n- # GH #12373 : rolling functions error on float32 data\n- # make sure the data is coerced to float64\n- try:\n- if isinstance(values, ExtensionArray):\n- values = values.to_numpy(np.float64, na_value=np.nan)\n- else:\n- values = ensure_float64(values)\n- except (ValueError, TypeError) as err:\n- raise TypeError(f\"cannot handle this type -> {values.dtype}\") from err\n-\n- # Convert inf to nan for C funcs\n- inf = np.isinf(values)\n- if inf.any():\n- values = np.where(inf, np.nan, values)\n-\n- return values\n-\n- def _insert_on_column(self, result: DataFrame, obj: DataFrame) -> None:\n- # if we have an 'on' column we want to put it back into\n- # the results in the same location\n- from pandas import Series\n-\n- if self.on is not None and not self._on.equals(obj.index):\n- name = self._on.name\n- extra_col = Series(self._on, index=self.obj.index, name=name)\n- if name in result.columns:\n- # TODO: sure we want to overwrite results?\n- result[name] = extra_col\n- elif name in result.index.names:\n- pass\n- elif name in self._selected_obj.columns:\n- # insert in the same location as we had in _selected_obj\n- old_cols = self._selected_obj.columns\n- new_cols = result.columns\n- old_loc = old_cols.get_loc(name)\n- overlap = new_cols.intersection(old_cols[:old_loc])\n- new_loc = len(overlap)\n- result.insert(new_loc, name, extra_col)\n- else:\n- # insert at the end\n- result[name] = extra_col\n-\n- @property\n- def _index_array(self):\n- # TODO: why do we get here with e.g. MultiIndex?\n- if needs_i8_conversion(self._on.dtype):\n- return self._on.asi8\n- return None\n-\n- def _resolve_output(self, out: DataFrame, obj: DataFrame) -> DataFrame:\n- \"\"\"Validate and finalize result.\"\"\"\n- if out.shape[1] == 0 and obj.shape[1] > 0:\n- raise DataError(\"No numeric types to aggregate\")\n- elif out.shape[1] == 0:\n- return obj.astype(\"float64\")\n-\n- self._insert_on_column(out, obj)\n- return out\n-\n- def _get_window_indexer(self) -> BaseIndexer:\n- \"\"\"\n- Return an indexer class that will compute the window start and end bounds\n- \"\"\"\n- if isinstance(self.window, BaseIndexer):\n- return self.window\n- if self._win_freq_i8 is not None:\n- return VariableWindowIndexer(\n- index_array=self._index_array,\n- window_size=self._win_freq_i8,\n- center=self.center,\n- )\n- return FixedWindowIndexer(window_size=self.window)\n-\n- def _apply_series(\n- self, homogeneous_func: Callable[..., ArrayLike], name: str | None = None\n- ) -> Series:\n- \"\"\"\n- Series version of _apply_blockwise\n- \"\"\"\n- obj = self._create_data(self._selected_obj)\n-\n- if name == \"count\":\n- # GH 12541: Special case for count where we support date-like types\n- obj = notna(obj).astype(int)\n- try:\n- values = self._prep_values(obj._values)\n- except (TypeError, NotImplementedError) as err:\n- raise DataError(\"No numeric types to aggregate\") from err\n-\n- result = homogeneous_func(values)\n- index = self._slice_axis_for_step(obj.index, result)\n- return obj._constructor(result, index=index, name=obj.name)\n-\n- def _apply_blockwise(\n- self,\n- homogeneous_func: Callable[..., ArrayLike],\n- name: str,\n- numeric_only: bool = False,\n- ) -> DataFrame | Series:\n- \"\"\"\n- Apply the given function to the DataFrame broken down into homogeneous\n- sub-frames.\n- \"\"\"\n- self._validate_numeric_only(name, numeric_only)\n- if self._selected_obj.ndim == 1:\n- return self._apply_series(homogeneous_func, name)\n-\n- obj = self._create_data(self._selected_obj, numeric_only)\n- if name == \"count\":\n- # GH 12541: Special case for count where we support date-like types\n- obj = notna(obj).astype(int)\n- obj._mgr = obj._mgr.consolidate()\n-\n- def hfunc(values: ArrayLike) -> ArrayLike:\n- values = self._prep_values(values)\n- return homogeneous_func(values)\n-\n- if self.axis == 1:\n- obj = obj.T\n-\n- taker = []\n- res_values = []\n- for i, arr in enumerate(obj._iter_column_arrays()):\n- # GH#42736 operate column-wise instead of block-wise\n- try:\n- res = hfunc(arr)\n- except (TypeError, NotImplementedError):\n- pass\n- else:\n- res_values.append(res)\n- taker.append(i)\n-\n- index = self._slice_axis_for_step(\n- obj.index, res_values[0] if len(res_values) > 0 else None\n- )\n- df = type(obj)._from_arrays(\n- res_values,\n- index=index,\n- columns=obj.columns.take(taker),\n- verify_integrity=False,\n- )\n-\n- if self.axis == 1:\n- df = df.T\n-\n- if 0 != len(res_values) != len(obj.columns):\n- # GH#42738 ignore_failures dropped nuisance columns\n- dropped = obj.columns.difference(obj.columns.take(taker))\n- warnings.warn(\n- \"Dropping of nuisance columns in rolling operations \"\n- \"is deprecated; in a future version this will raise TypeError. \"\n- \"Select only valid columns before calling the operation. \"\n- f\"Dropped columns were {dropped}\",\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n-\n- return self._resolve_output(df, obj)\n-\n- def _apply_tablewise(\n- self,\n- homogeneous_func: Callable[..., ArrayLike],\n- name: str | None = None,\n- numeric_only: bool = False,\n- ) -> DataFrame | Series:\n- \"\"\"\n- Apply the given function to the DataFrame across the entire object\n- \"\"\"\n- if self._selected_obj.ndim == 1:\n- raise ValueError(\"method='table' not applicable for Series objects.\")\n- obj = self._create_data(self._selected_obj, numeric_only)\n- values = self._prep_values(obj.to_numpy())\n- values = values.T if self.axis == 1 else values\n- result = homogeneous_func(values)\n- result = result.T if self.axis == 1 else result\n- index = self._slice_axis_for_step(obj.index, result)\n- columns = (\n- obj.columns\n- if result.shape[1] == len(obj.columns)\n- else obj.columns[:: self.step]\n- )\n- out = obj._constructor(result, index=index, columns=columns)\n-\n- return self._resolve_output(out, obj)\n-\n- def _apply_pairwise(\n- self,\n- target: DataFrame | Series,\n- other: DataFrame | Series | None,\n- pairwise: bool | None,\n- func: Callable[[DataFrame | Series, DataFrame | Series], DataFrame | Series],\n- numeric_only: bool,\n- ) -> DataFrame | Series:\n- \"\"\"\n- Apply the given pairwise function given 2 pandas objects (DataFrame/Series)\n- \"\"\"\n- target = self._create_data(target, numeric_only)\n- if other is None:\n- other = target\n- # only default unset\n- pairwise = True if pairwise is None else pairwise\n- elif not isinstance(other, (ABCDataFrame, ABCSeries)):\n- raise ValueError(\"other must be a DataFrame or Series\")\n- elif other.ndim == 2 and numeric_only:\n- other = self._make_numeric_only(other)\n-\n- return flex_binary_moment(target, other, func, pairwise=bool(pairwise))\n-\n- def _apply(\n- self,\n- func: Callable[..., Any],\n- name: str,\n- numeric_only: bool = False,\n- numba_args: tuple[Any, ...] = (),\n- **kwargs,\n- ):\n- \"\"\"\n- Rolling statistical measure using supplied function.\n-\n- Designed to be used with passed-in Cython array-based functions.\n-\n- Parameters\n- ----------\n- func : callable function to apply\n- name : str,\n- numba_args : tuple\n- args to be passed when func is a numba func\n- **kwargs\n- additional arguments for rolling function and window function\n-\n- Returns\n- -------\n- y : type of input\n- \"\"\"\n- window_indexer = self._get_window_indexer()\n- min_periods = (\n- self.min_periods\n- if self.min_periods is not None\n- else window_indexer.window_size\n- )\n-\n- def homogeneous_func(values: np.ndarray):\n- # calculation function\n-\n- if values.size == 0:\n- return values.copy()\n-\n- def calc(x):\n- start, end = window_indexer.get_window_bounds(\n- num_values=len(x),\n- min_periods=min_periods,\n- center=self.center,\n- closed=self.closed,\n- step=self.step,\n- )\n- self._check_window_bounds(start, end, len(x))\n-\n- return func(x, start, end, min_periods, *numba_args)\n-\n- with np.errstate(all=\"ignore\"):\n- result = calc(values)\n-\n- return result\n-\n- if self.method == \"single\":\n- return self._apply_blockwise(homogeneous_func, name, numeric_only)\n- else:\n- return self._apply_tablewise(homogeneous_func, name, numeric_only)\n-\n- def _numba_apply(\n- self,\n- func: Callable[..., Any],\n- engine_kwargs: dict[str, bool] | None = None,\n- *func_args,\n- ):\n- window_indexer = self._get_window_indexer()\n- min_periods = (\n- self.min_periods\n- if self.min_periods is not None\n- else window_indexer.window_size\n- )\n- obj = self._create_data(self._selected_obj)\n- if self.axis == 1:\n- obj = obj.T\n- values = self._prep_values(obj.to_numpy())\n- if values.ndim == 1:\n- values = values.reshape(-1, 1)\n- start, end = window_indexer.get_window_bounds(\n- num_values=len(values),\n- min_periods=min_periods,\n- center=self.center,\n- closed=self.closed,\n- step=self.step,\n- )\n- self._check_window_bounds(start, end, len(values))\n- aggregator = executor.generate_shared_aggregator(\n- func, **get_jit_arguments(engine_kwargs)\n- )\n- result = aggregator(values, start, end, min_periods, *func_args)\n- result = result.T if self.axis == 1 else result\n- index = self._slice_axis_for_step(obj.index, result)\n- if obj.ndim == 1:\n- result = result.squeeze()\n- out = obj._constructor(result, index=index, name=obj.name)\n- return out\n- else:\n- columns = self._slice_axis_for_step(obj.columns, result.T)\n- out = obj._constructor(result, index=index, columns=columns)\n- return self._resolve_output(out, obj)\n-\n- def aggregate(self, func, *args, **kwargs):\n- result = ResamplerWindowApply(self, func, args=args, kwargs=kwargs).agg()\n- if result is None:\n- return self.apply(func, raw=False, args=args, kwargs=kwargs)\n- return result\n-\n- agg = aggregate\n-\n-\n-class BaseWindowGroupby(BaseWindow):\n- \"\"\"\n- Provide the groupby windowing facilities.\n- \"\"\"\n-\n- _grouper: BaseGrouper\n- _as_index: bool\n- _attributes: list[str] = [\"_grouper\"]\n-\n- def __init__(\n- self,\n- obj: DataFrame | Series,\n- *args,\n- _grouper: BaseGrouper,\n- _as_index: bool = True,\n- **kwargs,\n- ) -> None:\n- from pandas.core.groupby.ops import BaseGrouper\n-\n- if not isinstance(_grouper, BaseGrouper):\n- raise ValueError(\"Must pass a BaseGrouper object.\")\n- self._grouper = _grouper\n- self._as_index = _as_index\n- # GH 32262: It's convention to keep the grouping column in\n- # groupby.<agg_func>, but unexpected to users in\n- # groupby.rolling.<agg_func>\n- obj = obj.drop(columns=self._grouper.names, errors=\"ignore\")\n- # GH 15354\n- if kwargs.get(\"step\") is not None:\n- raise NotImplementedError(\"step not implemented for groupby\")\n- super().__init__(obj, *args, **kwargs)\n-\n- def _apply(\n- self,\n- func: Callable[..., Any],\n- name: str,\n- numeric_only: bool = False,\n- numba_args: tuple[Any, ...] = (),\n- **kwargs,\n- ) -> DataFrame | Series:\n- result = super()._apply(\n- func,\n- name,\n- numeric_only,\n- numba_args,\n- **kwargs,\n- )\n- # Reconstruct the resulting MultiIndex\n- # 1st set of levels = group by labels\n- # 2nd set of levels = original DataFrame/Series index\n- grouped_object_index = self.obj.index\n- grouped_index_name = [*grouped_object_index.names]\n- groupby_keys = copy.copy(self._grouper.names)\n- result_index_names = groupby_keys + grouped_index_name\n-\n- drop_columns = [\n- key\n- for key in self._grouper.names\n- if key not in self.obj.index.names or key is None\n- ]\n-\n- if len(drop_columns) != len(groupby_keys):\n- # Our result will have still kept the column in the result\n- result = result.drop(columns=drop_columns, errors=\"ignore\")\n-\n- codes = self._grouper.codes\n- levels = copy.copy(self._grouper.levels)\n-\n- group_indices = self._grouper.indices.values()\n- if group_indices:\n- indexer = np.concatenate(list(group_indices))\n- else:\n- indexer = np.array([], dtype=np.intp)\n- codes = [c.take(indexer) for c in codes]\n-\n- # if the index of the original dataframe needs to be preserved, append\n- # this index (but reordered) to the codes/levels from the groupby\n- if grouped_object_index is not None:\n- idx = grouped_object_index.take(indexer)\n- if not isinstance(idx, MultiIndex):\n- idx = MultiIndex.from_arrays([idx])\n- codes.extend(list(idx.codes))\n- levels.extend(list(idx.levels))\n-\n- result_index = MultiIndex(\n- levels, codes, names=result_index_names, verify_integrity=False\n- )\n-\n- result.index = result_index\n- if not self._as_index:\n- result = result.reset_index(level=list(range(len(groupby_keys))))\n- return result\n-\n- def _apply_pairwise(\n- self,\n- target: DataFrame | Series,\n- other: DataFrame | Series | None,\n- pairwise: bool | None,\n- func: Callable[[DataFrame | Series, DataFrame | Series], DataFrame | Series],\n- numeric_only: bool,\n- ) -> DataFrame | Series:\n- \"\"\"\n- Apply the given pairwise function given 2 pandas objects (DataFrame/Series)\n- \"\"\"\n- # Manually drop the grouping column first\n- target = target.drop(columns=self._grouper.names, errors=\"ignore\")\n- result = super()._apply_pairwise(target, other, pairwise, func, numeric_only)\n- # 1) Determine the levels + codes of the groupby levels\n- if other is not None and not all(\n- len(group) == len(other) for group in self._grouper.indices.values()\n- ):\n- # GH 42915\n- # len(other) != len(any group), so must reindex (expand) the result\n- # from flex_binary_moment to a \"transform\"-like result\n- # per groupby combination\n- old_result_len = len(result)\n- result = concat(\n- [\n- result.take(gb_indices).reindex(result.index)\n- for gb_indices in self._grouper.indices.values()\n- ]\n- )\n-\n- gb_pairs = (\n- com.maybe_make_list(pair) for pair in self._grouper.indices.keys()\n- )\n- groupby_codes = []\n- groupby_levels = []\n- # e.g. [[1, 2], [4, 5]] as [[1, 4], [2, 5]]\n- for gb_level_pair in map(list, zip(*gb_pairs)):\n- labels = np.repeat(np.array(gb_level_pair), old_result_len)\n- codes, levels = factorize(labels)\n- groupby_codes.append(codes)\n- groupby_levels.append(levels)\n- else:\n- # pairwise=True or len(other) == len(each group), so repeat\n- # the groupby labels by the number of columns in the original object\n- groupby_codes = self._grouper.codes\n- # error: Incompatible types in assignment (expression has type\n- # \"List[Index]\", variable has type \"List[Union[ndarray, Index]]\")\n- groupby_levels = self._grouper.levels # type: ignore[assignment]\n-\n- group_indices = self._grouper.indices.values()\n- if group_indices:\n- indexer = np.concatenate(list(group_indices))\n- else:\n- indexer = np.array([], dtype=np.intp)\n-\n- if target.ndim == 1:\n- repeat_by = 1\n- else:\n- repeat_by = len(target.columns)\n- groupby_codes = [\n- np.repeat(c.take(indexer), repeat_by) for c in groupby_codes\n- ]\n- # 2) Determine the levels + codes of the result from super()._apply_pairwise\n- if isinstance(result.index, MultiIndex):\n- result_codes = list(result.index.codes)\n- result_levels = list(result.index.levels)\n- result_names = list(result.index.names)\n- else:\n- idx_codes, idx_levels = factorize(result.index)\n- result_codes = [idx_codes]\n- result_levels = [idx_levels]\n- result_names = [result.index.name]\n-\n- # 3) Create the resulting index by combining 1) + 2)\n- result_codes = groupby_codes + result_codes\n- result_levels = groupby_levels + result_levels\n- result_names = self._grouper.names + result_names\n-\n- result_index = MultiIndex(\n- result_levels, result_codes, names=result_names, verify_integrity=False\n- )\n- result.index = result_index\n- return result\n-\n- def _create_data(self, obj: NDFrameT, numeric_only: bool = False) -> NDFrameT:\n- \"\"\"\n- Split data into blocks & return conformed data.\n- \"\"\"\n- # Ensure the object we're rolling over is monotonically sorted relative\n- # to the groups\n- # GH 36197\n- if not obj.empty:\n- groupby_order = np.concatenate(list(self._grouper.indices.values())).astype(\n- np.int64\n- )\n- obj = obj.take(groupby_order)\n- return super()._create_data(obj, numeric_only)\n-\n- def _gotitem(self, key, ndim, subset=None):\n- # we are setting the index on the actual object\n- # here so our index is carried through to the selected obj\n- # when we do the splitting for the groupby\n- if self.on is not None:\n- # GH 43355\n- subset = self.obj.set_index(self._on)\n- return super()._gotitem(key, ndim, subset=subset)\n-\n-\n-class Window(BaseWindow):\n- \"\"\"\n- Provide rolling window calculations.\n-\n- Parameters\n- ----------\n- window : int, offset, or BaseIndexer subclass\n- Size of the moving window.\n-\n- If an integer, the fixed number of observations used for\n- each window.\n-\n- If an offset, the time period of each window. Each\n- window will be a variable sized based on the observations included in\n- the time-period. This is only valid for datetimelike indexes.\n- To learn more about the offsets & frequency strings, please see `this link\n- <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.\n-\n- If a BaseIndexer subclass, the window boundaries\n- based on the defined ``get_window_bounds`` method. Additional rolling\n- keyword arguments, namely ``min_periods``, ``center``, ``closed`` and\n- ``step`` will be passed to ``get_window_bounds``.\n-\n- min_periods : int, default None\n- Minimum number of observations in window required to have a value;\n- otherwise, result is ``np.nan``.\n-\n- For a window that is specified by an offset, ``min_periods`` will default to 1.\n-\n- For a window that is specified by an integer, ``min_periods`` will default\n- to the size of the window.\n-\n- center : bool, default False\n- If False, set the window labels as the right edge of the window index.\n-\n- If True, set the window labels as the center of the window index.\n-\n- win_type : str, default None\n- If ``None``, all points are evenly weighted.\n-\n- If a string, it must be a valid `scipy.signal window function\n- <https://docs.scipy.org/doc/scipy/reference/signal.windows.html#module-scipy.signal.windows>`__.\n-\n- Certain Scipy window types require additional parameters to be passed\n- in the aggregation function. The additional parameters must match\n- the keywords specified in the Scipy window type method signature.\n-\n- on : str, optional\n- For a DataFrame, a column label or Index level on which\n- to calculate the rolling window, rather than the DataFrame's index.\n-\n- Provided integer column is ignored and excluded from result since\n- an integer index is not used to calculate the rolling window.\n-\n- axis : int or str, default 0\n- If ``0`` or ``'index'``, roll across the rows.\n-\n- If ``1`` or ``'columns'``, roll across the columns.\n-\n- For `Series` this parameter is unused and defaults to 0.\n-\n- closed : str, default None\n- If ``'right'``, the first point in the window is excluded from calculations.\n-\n- If ``'left'``, the last point in the window is excluded from calculations.\n-\n- If ``'both'``, the no points in the window are excluded from calculations.\n-\n- If ``'neither'``, the first and last points in the window are excluded\n- from calculations.\n-\n- Default ``None`` (``'right'``).\n-\n- .. versionchanged:: 1.2.0\n-\n- The closed parameter with fixed windows is now supported.\n-\n- step : int, default None\n-\n- ..versionadded:: 1.5.0\n-\n- Evaluate the window at every ``step`` result, equivalent to slicing as\n- ``[::step]``. ``window`` must be an integer. Using a step argument other\n- than None or 1 will produce a result with a different shape than the input.\n-\n- method : str {'single', 'table'}, default 'single'\n-\n- .. versionadded:: 1.3.0\n-\n- Execute the rolling operation per single column or row (``'single'``)\n- or over the entire object (``'table'``).\n-\n- This argument is only implemented when specifying ``engine='numba'``\n- in the method call.\n-\n- Returns\n- -------\n- ``Window`` subclass if a ``win_type`` is passed\n-\n- ``Rolling`` subclass if ``win_type`` is not passed\n-\n- See Also\n- --------\n- expanding : Provides expanding transformations.\n- ewm : Provides exponential weighted functions.\n-\n- Notes\n- -----\n- See :ref:`Windowing Operations <window.generic>` for further usage details\n- and examples.\n-\n- Examples\n- --------\n- >>> df = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]})\n- >>> df\n- B\n- 0 0.0\n- 1 1.0\n- 2 2.0\n- 3 NaN\n- 4 4.0\n-\n- **window**\n-\n- Rolling sum with a window length of 2 observations.\n-\n- >>> df.rolling(2).sum()\n- B\n- 0 NaN\n- 1 1.0\n- 2 3.0\n- 3 NaN\n- 4 NaN\n-\n- Rolling sum with a window span of 2 seconds.\n-\n- >>> df_time = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]},\n- ... index = [pd.Timestamp('20130101 09:00:00'),\n- ... pd.Timestamp('20130101 09:00:02'),\n- ... pd.Timestamp('20130101 09:00:03'),\n- ... pd.Timestamp('20130101 09:00:05'),\n- ... pd.Timestamp('20130101 09:00:06')])\n-\n- >>> df_time\n- B\n- 2013-01-01 09:00:00 0.0\n- 2013-01-01 09:00:02 1.0\n- 2013-01-01 09:00:03 2.0\n- 2013-01-01 09:00:05 NaN\n- 2013-01-01 09:00:06 4.0\n-\n- >>> df_time.rolling('2s').sum()\n- B\n- 2013-01-01 09:00:00 0.0\n- 2013-01-01 09:00:02 1.0\n- 2013-01-01 09:00:03 3.0\n- 2013-01-01 09:00:05 NaN\n- 2013-01-01 09:00:06 4.0\n-\n- Rolling sum with forward looking windows with 2 observations.\n-\n- >>> indexer = pd.api.indexers.FixedForwardWindowIndexer(window_size=2)\n- >>> df.rolling(window=indexer, min_periods=1).sum()\n- B\n- 0 1.0\n- 1 3.0\n- 2 2.0\n- 3 4.0\n- 4 4.0\n-\n- **min_periods**\n-\n- Rolling sum with a window length of 2 observations, but only needs a minimum of 1\n- observation to calculate a value.\n-\n- >>> df.rolling(2, min_periods=1).sum()\n- B\n- 0 0.0\n- 1 1.0\n- 2 3.0\n- 3 2.0\n- 4 4.0\n-\n- **center**\n-\n- Rolling sum with the result assigned to the center of the window index.\n-\n- >>> df.rolling(3, min_periods=1, center=True).sum()\n- B\n- 0 1.0\n- 1 3.0\n- 2 3.0\n- 3 6.0\n- 4 4.0\n-\n- >>> df.rolling(3, min_periods=1, center=False).sum()\n- B\n- 0 0.0\n- 1 1.0\n- 2 3.0\n- 3 3.0\n- 4 6.0\n-\n- **step**\n-\n- Rolling sum with a window length of 2 observations, minimum of 1 observation to\n- calculate a value, and a step of 2.\n-\n- >>> df.rolling(2, min_periods=1, step=2).sum()\n- B\n- 0 0.0\n- 2 3.0\n- 4 4.0\n-\n- **win_type**\n-\n- Rolling sum with a window length of 2, using the Scipy ``'gaussian'``\n- window type. ``std`` is required in the aggregation function.\n-\n- >>> df.rolling(2, win_type='gaussian').sum(std=3)\n- B\n- 0 NaN\n- 1 0.986207\n- 2 2.958621\n- 3 NaN\n- 4 NaN\n- \"\"\"\n-\n- _attributes = [\n- \"window\",\n- \"min_periods\",\n- \"center\",\n- \"win_type\",\n- \"axis\",\n- \"on\",\n- \"closed\",\n- \"step\",\n- \"method\",\n- ]\n-\n- def _validate(self):\n- super()._validate()\n-\n- if not isinstance(self.win_type, str):\n- raise ValueError(f\"Invalid win_type {self.win_type}\")\n- signal = import_optional_dependency(\n- \"scipy.signal\", extra=\"Scipy is required to generate window weight.\"\n- )\n- self._scipy_weight_generator = getattr(signal, self.win_type, None)\n- if self._scipy_weight_generator is None:\n- raise ValueError(f\"Invalid win_type {self.win_type}\")\n-\n- if isinstance(self.window, BaseIndexer):\n- raise NotImplementedError(\n- \"BaseIndexer subclasses not implemented with win_types.\"\n- )\n- elif not is_integer(self.window) or self.window < 0:\n- raise ValueError(\"window must be an integer 0 or greater\")\n-\n- if self.method != \"single\":\n- raise NotImplementedError(\"'single' is the only supported method type.\")\n-\n- def _center_window(self, result: np.ndarray, offset: int) -> np.ndarray:\n- \"\"\"\n- Center the result in the window for weighted rolling aggregations.\n- \"\"\"\n- if offset > 0:\n- lead_indexer = [slice(offset, None)]\n- result = np.copy(result[tuple(lead_indexer)])\n- return result\n-\n- def _apply(\n- self,\n- func: Callable[[np.ndarray, int, int], np.ndarray],\n- name: str,\n- numeric_only: bool = False,\n- numba_args: tuple[Any, ...] = (),\n- **kwargs,\n- ):\n- \"\"\"\n- Rolling with weights statistical measure using supplied function.\n-\n- Designed to be used with passed-in Cython array-based functions.\n-\n- Parameters\n- ----------\n- func : callable function to apply\n- name : str,\n- numeric_only : bool, default False\n- Whether to only operate on bool, int, and float columns\n- numba_args : tuple\n- unused\n- **kwargs\n- additional arguments for scipy windows if necessary\n-\n- Returns\n- -------\n- y : type of input\n- \"\"\"\n- # \"None\" not callable [misc]\n- window = self._scipy_weight_generator( # type: ignore[misc]\n- self.window, **kwargs\n- )\n- offset = (len(window) - 1) // 2 if self.center else 0\n-\n- def homogeneous_func(values: np.ndarray):\n- # calculation function\n-\n- if values.size == 0:\n- return values.copy()\n-\n- def calc(x):\n- additional_nans = np.array([np.nan] * offset)\n- x = np.concatenate((x, additional_nans))\n- return func(x, window, self.min_periods or len(window))\n-\n- with np.errstate(all=\"ignore\"):\n- # Our weighted aggregations return memoryviews\n- result = np.asarray(calc(values))\n-\n- if self.center:\n- result = self._center_window(result, offset)\n-\n- return result\n-\n- return self._apply_blockwise(homogeneous_func, name, numeric_only)[:: self.step]\n-\n- @doc(\n- _shared_docs[\"aggregate\"],\n- see_also=dedent(\n- \"\"\"\n- See Also\n- --------\n- pandas.DataFrame.aggregate : Similar DataFrame method.\n- pandas.Series.aggregate : Similar Series method.\n- \"\"\"\n- ),\n- examples=dedent(\n- \"\"\"\n- Examples\n- --------\n- >>> df = pd.DataFrame({\"A\": [1, 2, 3], \"B\": [4, 5, 6], \"C\": [7, 8, 9]})\n- >>> df\n- A B C\n- 0 1 4 7\n- 1 2 5 8\n- 2 3 6 9\n-\n- >>> df.rolling(2, win_type=\"boxcar\").agg(\"mean\")\n- A B C\n- 0 NaN NaN NaN\n- 1 1.5 4.5 7.5\n- 2 2.5 5.5 8.5\n- \"\"\"\n- ),\n- klass=\"Series/DataFrame\",\n- axis=\"\",\n- )\n- def aggregate(self, func, *args, **kwargs):\n- result = ResamplerWindowApply(self, func, args=args, kwargs=kwargs).agg()\n- if result is None:\n-\n- # these must apply directly\n- result = func(self)\n-\n- return result\n-\n- agg = aggregate\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- kwargs_scipy,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also[:-1],\n- window_method=\"rolling\",\n- aggregation_description=\"weighted window sum\",\n- agg_method=\"sum\",\n- )\n- def sum(self, numeric_only: bool = False, *args, **kwargs):\n- nv.validate_window_func(\"sum\", args, kwargs)\n- window_func = window_aggregations.roll_weighted_sum\n- # error: Argument 1 to \"_apply\" of \"Window\" has incompatible type\n- # \"Callable[[ndarray, ndarray, int], ndarray]\"; expected\n- # \"Callable[[ndarray, int, int], ndarray]\"\n- return self._apply(\n- window_func, # type: ignore[arg-type]\n- name=\"sum\",\n- numeric_only=numeric_only,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- kwargs_scipy,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also[:-1],\n- window_method=\"rolling\",\n- aggregation_description=\"weighted window mean\",\n- agg_method=\"mean\",\n- )\n- def mean(self, numeric_only: bool = False, *args, **kwargs):\n- nv.validate_window_func(\"mean\", args, kwargs)\n- window_func = window_aggregations.roll_weighted_mean\n- # error: Argument 1 to \"_apply\" of \"Window\" has incompatible type\n- # \"Callable[[ndarray, ndarray, int], ndarray]\"; expected\n- # \"Callable[[ndarray, int, int], ndarray]\"\n- return self._apply(\n- window_func, # type: ignore[arg-type]\n- name=\"mean\",\n- numeric_only=numeric_only,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- \".. versionadded:: 1.0.0 \\n\\n\",\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- kwargs_scipy,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also[:-1],\n- window_method=\"rolling\",\n- aggregation_description=\"weighted window variance\",\n- agg_method=\"var\",\n- )\n- def var(self, ddof: int = 1, numeric_only: bool = False, *args, **kwargs):\n- nv.validate_window_func(\"var\", args, kwargs)\n- window_func = partial(window_aggregations.roll_weighted_var, ddof=ddof)\n- kwargs.pop(\"name\", None)\n- return self._apply(window_func, name=\"var\", numeric_only=numeric_only, **kwargs)\n-\n- @doc(\n- template_header,\n- \".. versionadded:: 1.0.0 \\n\\n\",\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- kwargs_scipy,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also[:-1],\n- window_method=\"rolling\",\n- aggregation_description=\"weighted window standard deviation\",\n- agg_method=\"std\",\n- )\n- def std(self, ddof: int = 1, numeric_only: bool = False, *args, **kwargs):\n- nv.validate_window_func(\"std\", args, kwargs)\n- return zsqrt(\n- self.var(ddof=ddof, name=\"std\", numeric_only=numeric_only, **kwargs)\n- )\n-\n-\n-class RollingAndExpandingMixin(BaseWindow):\n- def count(self, numeric_only: bool = False):\n- window_func = window_aggregations.roll_sum\n- return self._apply(window_func, name=\"count\", numeric_only=numeric_only)\n-\n- def apply(\n- self,\n- func: Callable[..., Any],\n- raw: bool = False,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- args: tuple[Any, ...] | None = None,\n- kwargs: dict[str, Any] | None = None,\n- ):\n- if args is None:\n- args = ()\n- if kwargs is None:\n- kwargs = {}\n-\n- if not is_bool(raw):\n- raise ValueError(\"raw parameter must be `True` or `False`\")\n-\n- numba_args: tuple[Any, ...] = ()\n- if maybe_use_numba(engine):\n- if raw is False:\n- raise ValueError(\"raw must be `True` when using the numba engine\")\n- numba_args = args\n- if self.method == \"single\":\n- apply_func = generate_numba_apply_func(\n- func, **get_jit_arguments(engine_kwargs, kwargs)\n- )\n- else:\n- apply_func = generate_numba_table_func(\n- func, **get_jit_arguments(engine_kwargs, kwargs)\n- )\n- elif engine in (\"cython\", None):\n- if engine_kwargs is not None:\n- raise ValueError(\"cython engine does not accept engine_kwargs\")\n- apply_func = self._generate_cython_apply_func(args, kwargs, raw, func)\n- else:\n- raise ValueError(\"engine must be either 'numba' or 'cython'\")\n-\n- return self._apply(\n- apply_func,\n- name=\"apply\",\n- numba_args=numba_args,\n- )\n-\n- def _generate_cython_apply_func(\n- self,\n- args: tuple[Any, ...],\n- kwargs: dict[str, Any],\n- raw: bool,\n- function: Callable[..., Any],\n- ) -> Callable[[np.ndarray, np.ndarray, np.ndarray, int], np.ndarray]:\n- from pandas import Series\n-\n- window_func = partial(\n- window_aggregations.roll_apply,\n- args=args,\n- kwargs=kwargs,\n- raw=raw,\n- function=function,\n- )\n-\n- def apply_func(values, begin, end, min_periods, raw=raw):\n- if not raw:\n- # GH 45912\n- values = Series(values, index=self._on)\n- return window_func(values, begin, end, min_periods)\n-\n- return apply_func\n-\n- def sum(\n- self,\n- numeric_only: bool = False,\n- *args,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- nv.validate_window_func(\"sum\", args, kwargs)\n- if maybe_use_numba(engine):\n- if self.method == \"table\":\n- func = generate_manual_numpy_nan_agg_with_axis(np.nansum)\n- return self.apply(\n- func,\n- raw=True,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- )\n- else:\n- from pandas.core._numba.kernels import sliding_sum\n-\n- return self._numba_apply(sliding_sum, engine_kwargs)\n- window_func = window_aggregations.roll_sum\n- return self._apply(window_func, name=\"sum\", numeric_only=numeric_only, **kwargs)\n-\n- def max(\n- self,\n- numeric_only: bool = False,\n- *args,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- nv.validate_window_func(\"max\", args, kwargs)\n- if maybe_use_numba(engine):\n- if self.method == \"table\":\n- func = generate_manual_numpy_nan_agg_with_axis(np.nanmax)\n- return self.apply(\n- func,\n- raw=True,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- )\n- else:\n- from pandas.core._numba.kernels import sliding_min_max\n-\n- return self._numba_apply(sliding_min_max, engine_kwargs, True)\n- window_func = window_aggregations.roll_max\n- return self._apply(window_func, name=\"max\", numeric_only=numeric_only, **kwargs)\n-\n- def min(\n- self,\n- numeric_only: bool = False,\n- *args,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- nv.validate_window_func(\"min\", args, kwargs)\n- if maybe_use_numba(engine):\n- if self.method == \"table\":\n- func = generate_manual_numpy_nan_agg_with_axis(np.nanmin)\n- return self.apply(\n- func,\n- raw=True,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- )\n- else:\n- from pandas.core._numba.kernels import sliding_min_max\n-\n- return self._numba_apply(sliding_min_max, engine_kwargs, False)\n- window_func = window_aggregations.roll_min\n- return self._apply(window_func, name=\"min\", numeric_only=numeric_only, **kwargs)\n-\n- def mean(\n- self,\n- numeric_only: bool = False,\n- *args,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- nv.validate_window_func(\"mean\", args, kwargs)\n- if maybe_use_numba(engine):\n- if self.method == \"table\":\n- func = generate_manual_numpy_nan_agg_with_axis(np.nanmean)\n- return self.apply(\n- func,\n- raw=True,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- )\n- else:\n- from pandas.core._numba.kernels import sliding_mean\n-\n- return self._numba_apply(sliding_mean, engine_kwargs)\n- window_func = window_aggregations.roll_mean\n- return self._apply(\n- window_func, name=\"mean\", numeric_only=numeric_only, **kwargs\n- )\n-\n- def median(\n- self,\n- numeric_only: bool = False,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- if maybe_use_numba(engine):\n- if self.method == \"table\":\n- func = generate_manual_numpy_nan_agg_with_axis(np.nanmedian)\n- else:\n- func = np.nanmedian\n-\n- return self.apply(\n- func,\n- raw=True,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- )\n- window_func = window_aggregations.roll_median_c\n- return self._apply(\n- window_func, name=\"median\", numeric_only=numeric_only, **kwargs\n- )\n-\n- def std(\n- self,\n- ddof: int = 1,\n- numeric_only: bool = False,\n- *args,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- nv.validate_window_func(\"std\", args, kwargs)\n- if maybe_use_numba(engine):\n- if self.method == \"table\":\n- raise NotImplementedError(\"std not supported with method='table'\")\n- else:\n- from pandas.core._numba.kernels import sliding_var\n-\n- return zsqrt(self._numba_apply(sliding_var, engine_kwargs, ddof))\n- window_func = window_aggregations.roll_var\n-\n- def zsqrt_func(values, begin, end, min_periods):\n- return zsqrt(window_func(values, begin, end, min_periods, ddof=ddof))\n-\n- return self._apply(\n- zsqrt_func,\n- name=\"std\",\n- numeric_only=numeric_only,\n- **kwargs,\n- )\n-\n- def var(\n- self,\n- ddof: int = 1,\n- numeric_only: bool = False,\n- *args,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- nv.validate_window_func(\"var\", args, kwargs)\n- if maybe_use_numba(engine):\n- if self.method == \"table\":\n- raise NotImplementedError(\"var not supported with method='table'\")\n- else:\n- from pandas.core._numba.kernels import sliding_var\n-\n- return self._numba_apply(sliding_var, engine_kwargs, ddof)\n- window_func = partial(window_aggregations.roll_var, ddof=ddof)\n- return self._apply(\n- window_func,\n- name=\"var\",\n- numeric_only=numeric_only,\n- **kwargs,\n- )\n-\n- def skew(self, numeric_only: bool = False, **kwargs):\n- window_func = window_aggregations.roll_skew\n- return self._apply(\n- window_func,\n- name=\"skew\",\n- numeric_only=numeric_only,\n- **kwargs,\n- )\n-\n- def sem(self, ddof: int = 1, numeric_only: bool = False, *args, **kwargs):\n- nv.validate_rolling_func(\"sem\", args, kwargs)\n- # Raise here so error message says sem instead of std\n- self._validate_numeric_only(\"sem\", numeric_only)\n- return self.std(numeric_only=numeric_only, **kwargs) / (\n- self.count(numeric_only=numeric_only) - ddof\n- ).pow(0.5)\n-\n- def kurt(self, numeric_only: bool = False, **kwargs):\n- window_func = window_aggregations.roll_kurt\n- return self._apply(\n- window_func,\n- name=\"kurt\",\n- numeric_only=numeric_only,\n- **kwargs,\n- )\n-\n- def quantile(\n- self,\n- quantile: float,\n- interpolation: str = \"linear\",\n- numeric_only: bool = False,\n- **kwargs,\n- ):\n- if quantile == 1.0:\n- window_func = window_aggregations.roll_max\n- elif quantile == 0.0:\n- window_func = window_aggregations.roll_min\n- else:\n- window_func = partial(\n- window_aggregations.roll_quantile,\n- quantile=quantile,\n- interpolation=interpolation,\n- )\n-\n- return self._apply(\n- window_func, name=\"quantile\", numeric_only=numeric_only, **kwargs\n- )\n-\n- def rank(\n- self,\n- method: WindowingRankType = \"average\",\n- ascending: bool = True,\n- pct: bool = False,\n- numeric_only: bool = False,\n- **kwargs,\n- ):\n- window_func = partial(\n- window_aggregations.roll_rank,\n- method=method,\n- ascending=ascending,\n- percentile=pct,\n- )\n-\n- return self._apply(\n- window_func, name=\"rank\", numeric_only=numeric_only, **kwargs\n- )\n-\n- def cov(\n- self,\n- other: DataFrame | Series | None = None,\n- pairwise: bool | None = None,\n- ddof: int = 1,\n- numeric_only: bool = False,\n- **kwargs,\n- ):\n- if self.step is not None:\n- raise NotImplementedError(\"step not implemented for cov\")\n- self._validate_numeric_only(\"cov\", numeric_only)\n-\n- from pandas import Series\n-\n- def cov_func(x, y):\n- x_array = self._prep_values(x)\n- y_array = self._prep_values(y)\n- window_indexer = self._get_window_indexer()\n- min_periods = (\n- self.min_periods\n- if self.min_periods is not None\n- else window_indexer.window_size\n- )\n- start, end = window_indexer.get_window_bounds(\n- num_values=len(x_array),\n- min_periods=min_periods,\n- center=self.center,\n- closed=self.closed,\n- step=self.step,\n- )\n- self._check_window_bounds(start, end, len(x_array))\n-\n- with np.errstate(all=\"ignore\"):\n- mean_x_y = window_aggregations.roll_mean(\n- x_array * y_array, start, end, min_periods\n- )\n- mean_x = window_aggregations.roll_mean(x_array, start, end, min_periods)\n- mean_y = window_aggregations.roll_mean(y_array, start, end, min_periods)\n- count_x_y = window_aggregations.roll_sum(\n- notna(x_array + y_array).astype(np.float64), start, end, 0\n- )\n- result = (mean_x_y - mean_x * mean_y) * (count_x_y / (count_x_y - ddof))\n- return Series(result, index=x.index, name=x.name)\n-\n- return self._apply_pairwise(\n- self._selected_obj, other, pairwise, cov_func, numeric_only\n- )\n-\n- def corr(\n- self,\n- other: DataFrame | Series | None = None,\n- pairwise: bool | None = None,\n- ddof: int = 1,\n- numeric_only: bool = False,\n- **kwargs,\n- ):\n- if self.step is not None:\n- raise NotImplementedError(\"step not implemented for corr\")\n- self._validate_numeric_only(\"corr\", numeric_only)\n-\n- from pandas import Series\n-\n- def corr_func(x, y):\n- x_array = self._prep_values(x)\n- y_array = self._prep_values(y)\n- window_indexer = self._get_window_indexer()\n- min_periods = (\n- self.min_periods\n- if self.min_periods is not None\n- else window_indexer.window_size\n- )\n- start, end = window_indexer.get_window_bounds(\n- num_values=len(x_array),\n- min_periods=min_periods,\n- center=self.center,\n- closed=self.closed,\n- step=self.step,\n- )\n- self._check_window_bounds(start, end, len(x_array))\n-\n- with np.errstate(all=\"ignore\"):\n- mean_x_y = window_aggregations.roll_mean(\n- x_array * y_array, start, end, min_periods\n- )\n- mean_x = window_aggregations.roll_mean(x_array, start, end, min_periods)\n- mean_y = window_aggregations.roll_mean(y_array, start, end, min_periods)\n- count_x_y = window_aggregations.roll_sum(\n- notna(x_array + y_array).astype(np.float64), start, end, 0\n- )\n- x_var = window_aggregations.roll_var(\n- x_array, start, end, min_periods, ddof\n- )\n- y_var = window_aggregations.roll_var(\n- y_array, start, end, min_periods, ddof\n- )\n- numerator = (mean_x_y - mean_x * mean_y) * (\n- count_x_y / (count_x_y - ddof)\n- )\n- denominator = (x_var * y_var) ** 0.5\n- result = numerator / denominator\n- return Series(result, index=x.index, name=x.name)\n-\n- return self._apply_pairwise(\n- self._selected_obj, other, pairwise, corr_func, numeric_only\n- )\n-\n-\n-class Rolling(RollingAndExpandingMixin):\n-\n- _attributes: list[str] = [\n- \"window\",\n- \"min_periods\",\n- \"center\",\n- \"win_type\",\n- \"axis\",\n- \"on\",\n- \"closed\",\n- \"step\",\n- \"method\",\n- ]\n-\n- def _validate(self):\n- super()._validate()\n-\n- # we allow rolling on a datetimelike index\n- if (\n- self.obj.empty\n- or isinstance(self._on, (DatetimeIndex, TimedeltaIndex, PeriodIndex))\n- ) and isinstance(self.window, (str, BaseOffset, timedelta)):\n-\n- self._validate_datetimelike_monotonic()\n-\n- # this will raise ValueError on non-fixed freqs\n- try:\n- freq = to_offset(self.window)\n- except (TypeError, ValueError) as err:\n- raise ValueError(\n- f\"passed window {self.window} is not \"\n- \"compatible with a datetimelike index\"\n- ) from err\n- if isinstance(self._on, PeriodIndex):\n- # error: Incompatible types in assignment (expression has type \"float\",\n- # variable has type \"None\")\n- self._win_freq_i8 = freq.nanos / ( # type: ignore[assignment]\n- self._on.freq.nanos / self._on.freq.n\n- )\n- else:\n- # error: Incompatible types in assignment (expression has type \"int\",\n- # variable has type \"None\")\n- self._win_freq_i8 = freq.nanos # type: ignore[assignment]\n-\n- # min_periods must be an integer\n- if self.min_periods is None:\n- self.min_periods = 1\n-\n- if self.step is not None:\n- raise NotImplementedError(\n- \"step is not supported with frequency windows\"\n- )\n-\n- elif isinstance(self.window, BaseIndexer):\n- # Passed BaseIndexer subclass should handle all other rolling kwargs\n- pass\n- elif not is_integer(self.window) or self.window < 0:\n- raise ValueError(\"window must be an integer 0 or greater\")\n-\n- def _validate_datetimelike_monotonic(self):\n- \"\"\"\n- Validate self._on is monotonic (increasing or decreasing) and has\n- no NaT values for frequency windows.\n- \"\"\"\n- if self._on.hasnans:\n- self._raise_monotonic_error(\"values must not have NaT\")\n- if not (self._on.is_monotonic_increasing or self._on.is_monotonic_decreasing):\n- self._raise_monotonic_error(\"values must be monotonic\")\n-\n- def _raise_monotonic_error(self, msg: str):\n- on = self.on\n- if on is None:\n- if self.axis == 0:\n- on = \"index\"\n- else:\n- on = \"column\"\n- raise ValueError(f\"{on} {msg}\")\n-\n- @doc(\n- _shared_docs[\"aggregate\"],\n- see_also=dedent(\n- \"\"\"\n- See Also\n- --------\n- pandas.Series.rolling : Calling object with Series data.\n- pandas.DataFrame.rolling : Calling object with DataFrame data.\n- \"\"\"\n- ),\n- examples=dedent(\n- \"\"\"\n- Examples\n- --------\n- >>> df = pd.DataFrame({\"A\": [1, 2, 3], \"B\": [4, 5, 6], \"C\": [7, 8, 9]})\n- >>> df\n- A B C\n- 0 1 4 7\n- 1 2 5 8\n- 2 3 6 9\n-\n- >>> df.rolling(2).sum()\n- A B C\n- 0 NaN NaN NaN\n- 1 3.0 9.0 15.0\n- 2 5.0 11.0 17.0\n-\n- >>> df.rolling(2).agg({\"A\": \"sum\", \"B\": \"min\"})\n- A B\n- 0 NaN NaN\n- 1 3.0 4.0\n- 2 5.0 5.0\n- \"\"\"\n- ),\n- klass=\"Series/Dataframe\",\n- axis=\"\",\n- )\n- def aggregate(self, func, *args, **kwargs):\n- return super().aggregate(func, *args, **kwargs)\n-\n- agg = aggregate\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also,\n- create_section_header(\"Examples\"),\n- dedent(\n- \"\"\"\n- >>> s = pd.Series([2, 3, np.nan, 10])\n- >>> s.rolling(2).count()\n- 0 1.0\n- 1 2.0\n- 2 1.0\n- 3 1.0\n- dtype: float64\n- >>> s.rolling(3).count()\n- 0 1.0\n- 1 2.0\n- 2 2.0\n- 3 2.0\n- dtype: float64\n- >>> s.rolling(4).count()\n- 0 1.0\n- 1 2.0\n- 2 2.0\n- 3 3.0\n- dtype: float64\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- window_method=\"rolling\",\n- aggregation_description=\"count of non NaN observations\",\n- agg_method=\"count\",\n- )\n- def count(self, numeric_only: bool = False):\n- if self.min_periods is None:\n- warnings.warn(\n- (\n- \"min_periods=None will default to the size of window \"\n- \"consistent with other methods in a future version. \"\n- \"Specify min_periods=0 instead.\"\n- ),\n- FutureWarning,\n- stacklevel=find_stack_level(),\n- )\n- self.min_periods = 0\n- result = super().count()\n- self.min_periods = None\n- else:\n- result = super().count(numeric_only)\n- return result\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- window_apply_parameters,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also[:-1],\n- window_method=\"rolling\",\n- aggregation_description=\"custom aggregation function\",\n- agg_method=\"apply\",\n- )\n- def apply(\n- self,\n- func: Callable[..., Any],\n- raw: bool = False,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- args: tuple[Any, ...] | None = None,\n- kwargs: dict[str, Any] | None = None,\n- ):\n- return super().apply(\n- func,\n- raw=raw,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- args=args,\n- kwargs=kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- args_compat,\n- window_agg_numba_parameters(),\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also,\n- create_section_header(\"Notes\"),\n- numba_notes,\n- create_section_header(\"Examples\"),\n- dedent(\n- \"\"\"\n- >>> s = pd.Series([1, 2, 3, 4, 5])\n- >>> s\n- 0 1\n- 1 2\n- 2 3\n- 3 4\n- 4 5\n- dtype: int64\n-\n- >>> s.rolling(3).sum()\n- 0 NaN\n- 1 NaN\n- 2 6.0\n- 3 9.0\n- 4 12.0\n- dtype: float64\n-\n- >>> s.rolling(3, center=True).sum()\n- 0 NaN\n- 1 6.0\n- 2 9.0\n- 3 12.0\n- 4 NaN\n- dtype: float64\n-\n- For DataFrame, each sum is computed column-wise.\n-\n- >>> df = pd.DataFrame({{\"A\": s, \"B\": s ** 2}})\n- >>> df\n- A B\n- 0 1 1\n- 1 2 4\n- 2 3 9\n- 3 4 16\n- 4 5 25\n-\n- >>> df.rolling(3).sum()\n- A B\n- 0 NaN NaN\n- 1 NaN NaN\n- 2 6.0 14.0\n- 3 9.0 29.0\n- 4 12.0 50.0\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- window_method=\"rolling\",\n- aggregation_description=\"sum\",\n- agg_method=\"sum\",\n- )\n- def sum(\n- self,\n- numeric_only: bool = False,\n- *args,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- nv.validate_rolling_func(\"sum\", args, kwargs)\n- return super().sum(\n- numeric_only=numeric_only,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- args_compat,\n- window_agg_numba_parameters(),\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also,\n- create_section_header(\"Notes\"),\n- numba_notes[:-1],\n- window_method=\"rolling\",\n- aggregation_description=\"maximum\",\n- agg_method=\"max\",\n- )\n- def max(\n- self,\n- numeric_only: bool = False,\n- *args,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- nv.validate_rolling_func(\"max\", args, kwargs)\n- return super().max(\n- numeric_only=numeric_only,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- args_compat,\n- window_agg_numba_parameters(),\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also,\n- create_section_header(\"Notes\"),\n- numba_notes,\n- create_section_header(\"Examples\"),\n- dedent(\n- \"\"\"\n- Performing a rolling minimum with a window size of 3.\n-\n- >>> s = pd.Series([4, 3, 5, 2, 6])\n- >>> s.rolling(3).min()\n- 0 NaN\n- 1 NaN\n- 2 3.0\n- 3 2.0\n- 4 2.0\n- dtype: float64\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- window_method=\"rolling\",\n- aggregation_description=\"minimum\",\n- agg_method=\"min\",\n- )\n- def min(\n- self,\n- numeric_only: bool = False,\n- *args,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- nv.validate_rolling_func(\"min\", args, kwargs)\n- return super().min(\n- numeric_only=numeric_only,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- args_compat,\n- window_agg_numba_parameters(),\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also,\n- create_section_header(\"Notes\"),\n- numba_notes,\n- create_section_header(\"Examples\"),\n- dedent(\n- \"\"\"\n- The below examples will show rolling mean calculations with window sizes of\n- two and three, respectively.\n-\n- >>> s = pd.Series([1, 2, 3, 4])\n- >>> s.rolling(2).mean()\n- 0 NaN\n- 1 1.5\n- 2 2.5\n- 3 3.5\n- dtype: float64\n-\n- >>> s.rolling(3).mean()\n- 0 NaN\n- 1 NaN\n- 2 2.0\n- 3 3.0\n- dtype: float64\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- window_method=\"rolling\",\n- aggregation_description=\"mean\",\n- agg_method=\"mean\",\n- )\n- def mean(\n- self,\n- numeric_only: bool = False,\n- *args,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- nv.validate_rolling_func(\"mean\", args, kwargs)\n- return super().mean(\n- numeric_only=numeric_only,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- window_agg_numba_parameters(),\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also,\n- create_section_header(\"Notes\"),\n- numba_notes,\n- create_section_header(\"Examples\"),\n- dedent(\n- \"\"\"\n- Compute the rolling median of a series with a window size of 3.\n-\n- >>> s = pd.Series([0, 1, 2, 3, 4])\n- >>> s.rolling(3).median()\n- 0 NaN\n- 1 NaN\n- 2 1.0\n- 3 2.0\n- 4 3.0\n- dtype: float64\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- window_method=\"rolling\",\n- aggregation_description=\"median\",\n- agg_method=\"median\",\n- )\n- def median(\n- self,\n- numeric_only: bool = False,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- return super().median(\n- numeric_only=numeric_only,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- dedent(\n- \"\"\"\n- ddof : int, default 1\n- Delta Degrees of Freedom. The divisor used in calculations\n- is ``N - ddof``, where ``N`` represents the number of elements.\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- kwargs_numeric_only,\n- args_compat,\n- window_agg_numba_parameters(\"1.4\"),\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- \"numpy.std : Equivalent method for NumPy array.\\n\",\n- template_see_also,\n- create_section_header(\"Notes\"),\n- dedent(\n- \"\"\"\n- The default ``ddof`` of 1 used in :meth:`Series.std` is different\n- than the default ``ddof`` of 0 in :func:`numpy.std`.\n-\n- A minimum of one period is required for the rolling calculation.\\n\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- create_section_header(\"Examples\"),\n- dedent(\n- \"\"\"\n- >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])\n- >>> s.rolling(3).std()\n- 0 NaN\n- 1 NaN\n- 2 0.577350\n- 3 1.000000\n- 4 1.000000\n- 5 1.154701\n- 6 0.000000\n- dtype: float64\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- window_method=\"rolling\",\n- aggregation_description=\"standard deviation\",\n- agg_method=\"std\",\n- )\n- def std(\n- self,\n- ddof: int = 1,\n- numeric_only: bool = False,\n- *args,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- nv.validate_rolling_func(\"std\", args, kwargs)\n- return super().std(\n- ddof=ddof,\n- numeric_only=numeric_only,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- dedent(\n- \"\"\"\n- ddof : int, default 1\n- Delta Degrees of Freedom. The divisor used in calculations\n- is ``N - ddof``, where ``N`` represents the number of elements.\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- kwargs_numeric_only,\n- args_compat,\n- window_agg_numba_parameters(\"1.4\"),\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- \"numpy.var : Equivalent method for NumPy array.\\n\",\n- template_see_also,\n- create_section_header(\"Notes\"),\n- dedent(\n- \"\"\"\n- The default ``ddof`` of 1 used in :meth:`Series.var` is different\n- than the default ``ddof`` of 0 in :func:`numpy.var`.\n-\n- A minimum of one period is required for the rolling calculation.\\n\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- create_section_header(\"Examples\"),\n- dedent(\n- \"\"\"\n- >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])\n- >>> s.rolling(3).var()\n- 0 NaN\n- 1 NaN\n- 2 0.333333\n- 3 1.000000\n- 4 1.000000\n- 5 1.333333\n- 6 0.000000\n- dtype: float64\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- window_method=\"rolling\",\n- aggregation_description=\"variance\",\n- agg_method=\"var\",\n- )\n- def var(\n- self,\n- ddof: int = 1,\n- numeric_only: bool = False,\n- *args,\n- engine: str | None = None,\n- engine_kwargs: dict[str, bool] | None = None,\n- **kwargs,\n- ):\n- nv.validate_rolling_func(\"var\", args, kwargs)\n- return super().var(\n- ddof=ddof,\n- numeric_only=numeric_only,\n- engine=engine,\n- engine_kwargs=engine_kwargs,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- \"scipy.stats.skew : Third moment of a probability density.\\n\",\n- template_see_also,\n- create_section_header(\"Notes\"),\n- \"A minimum of three periods is required for the rolling calculation.\\n\",\n- window_method=\"rolling\",\n- aggregation_description=\"unbiased skewness\",\n- agg_method=\"skew\",\n- )\n- def skew(self, numeric_only: bool = False, **kwargs):\n- return super().skew(numeric_only=numeric_only, **kwargs)\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- dedent(\n- \"\"\"\n- ddof : int, default 1\n- Delta Degrees of Freedom. The divisor used in calculations\n- is ``N - ddof``, where ``N`` represents the number of elements.\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- kwargs_numeric_only,\n- args_compat,\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also,\n- create_section_header(\"Notes\"),\n- \"A minimum of one period is required for the calculation.\\n\\n\",\n- create_section_header(\"Examples\"),\n- dedent(\n- \"\"\"\n- >>> s = pd.Series([0, 1, 2, 3])\n- >>> s.rolling(2, min_periods=1).sem()\n- 0 NaN\n- 1 0.707107\n- 2 0.707107\n- 3 0.707107\n- dtype: float64\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- window_method=\"rolling\",\n- aggregation_description=\"standard error of mean\",\n- agg_method=\"sem\",\n- )\n- def sem(self, ddof: int = 1, numeric_only: bool = False, *args, **kwargs):\n- nv.validate_rolling_func(\"sem\", args, kwargs)\n- # Raise here so error message says sem instead of std\n- self._validate_numeric_only(\"sem\", numeric_only)\n- return self.std(numeric_only=numeric_only, **kwargs) / (\n- self.count(numeric_only) - ddof\n- ).pow(0.5)\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- kwargs_numeric_only,\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- \"scipy.stats.kurtosis : Reference SciPy method.\\n\",\n- template_see_also,\n- create_section_header(\"Notes\"),\n- \"A minimum of four periods is required for the calculation.\\n\\n\",\n- create_section_header(\"Examples\"),\n- dedent(\n- \"\"\"\n- The example below will show a rolling calculation with a window size of\n- four matching the equivalent function call using `scipy.stats`.\n-\n- >>> arr = [1, 2, 3, 4, 999]\n- >>> import scipy.stats\n- >>> print(f\"{{scipy.stats.kurtosis(arr[:-1], bias=False):.6f}}\")\n- -1.200000\n- >>> print(f\"{{scipy.stats.kurtosis(arr[1:], bias=False):.6f}}\")\n- 3.999946\n- >>> s = pd.Series(arr)\n- >>> s.rolling(4).kurt()\n- 0 NaN\n- 1 NaN\n- 2 NaN\n- 3 -1.200000\n- 4 3.999946\n- dtype: float64\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- window_method=\"rolling\",\n- aggregation_description=\"Fisher's definition of kurtosis without bias\",\n- agg_method=\"kurt\",\n- )\n- def kurt(self, numeric_only: bool = False, **kwargs):\n- return super().kurt(numeric_only=numeric_only, **kwargs)\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- dedent(\n- \"\"\"\n- quantile : float\n- Quantile to compute. 0 <= quantile <= 1.\n- interpolation : {{'linear', 'lower', 'higher', 'midpoint', 'nearest'}}\n- This optional parameter specifies the interpolation method to use,\n- when the desired quantile lies between two data points `i` and `j`:\n-\n- * linear: `i + (j - i) * fraction`, where `fraction` is the\n- fractional part of the index surrounded by `i` and `j`.\n- * lower: `i`.\n- * higher: `j`.\n- * nearest: `i` or `j` whichever is nearest.\n- * midpoint: (`i` + `j`) / 2.\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- kwargs_numeric_only,\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also,\n- create_section_header(\"Examples\"),\n- dedent(\n- \"\"\"\n- >>> s = pd.Series([1, 2, 3, 4])\n- >>> s.rolling(2).quantile(.4, interpolation='lower')\n- 0 NaN\n- 1 1.0\n- 2 2.0\n- 3 3.0\n- dtype: float64\n-\n- >>> s.rolling(2).quantile(.4, interpolation='midpoint')\n- 0 NaN\n- 1 1.5\n- 2 2.5\n- 3 3.5\n- dtype: float64\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- window_method=\"rolling\",\n- aggregation_description=\"quantile\",\n- agg_method=\"quantile\",\n- )\n- def quantile(\n- self,\n- quantile: float,\n- interpolation: str = \"linear\",\n- numeric_only: bool = False,\n- **kwargs,\n- ):\n- return super().quantile(\n- quantile=quantile,\n- interpolation=interpolation,\n- numeric_only=numeric_only,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- \".. versionadded:: 1.4.0 \\n\\n\",\n- create_section_header(\"Parameters\"),\n- dedent(\n- \"\"\"\n- method : {{'average', 'min', 'max'}}, default 'average'\n- How to rank the group of records that have the same value (i.e. ties):\n-\n- * average: average rank of the group\n- * min: lowest rank in the group\n- * max: highest rank in the group\n-\n- ascending : bool, default True\n- Whether or not the elements should be ranked in ascending order.\n- pct : bool, default False\n- Whether or not to display the returned rankings in percentile\n- form.\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- kwargs_numeric_only,\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also,\n- create_section_header(\"Examples\"),\n- dedent(\n- \"\"\"\n- >>> s = pd.Series([1, 4, 2, 3, 5, 3])\n- >>> s.rolling(3).rank()\n- 0 NaN\n- 1 NaN\n- 2 2.0\n- 3 2.0\n- 4 3.0\n- 5 1.5\n- dtype: float64\n-\n- >>> s.rolling(3).rank(method=\"max\")\n- 0 NaN\n- 1 NaN\n- 2 2.0\n- 3 2.0\n- 4 3.0\n- 5 2.0\n- dtype: float64\n-\n- >>> s.rolling(3).rank(method=\"min\")\n- 0 NaN\n- 1 NaN\n- 2 2.0\n- 3 2.0\n- 4 3.0\n- 5 1.0\n- dtype: float64\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- window_method=\"rolling\",\n- aggregation_description=\"rank\",\n- agg_method=\"rank\",\n- )\n- def rank(\n- self,\n- method: WindowingRankType = \"average\",\n- ascending: bool = True,\n- pct: bool = False,\n- numeric_only: bool = False,\n- **kwargs,\n- ):\n- return super().rank(\n- method=method,\n- ascending=ascending,\n- pct=pct,\n- numeric_only=numeric_only,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- dedent(\n- \"\"\"\n- other : Series or DataFrame, optional\n- If not supplied then will default to self and produce pairwise\n- output.\n- pairwise : bool, default None\n- If False then only matching columns between self and other will be\n- used and the output will be a DataFrame.\n- If True then all pairwise combinations will be calculated and the\n- output will be a MultiIndexed DataFrame in the case of DataFrame\n- inputs. In the case of missing elements, only complete pairwise\n- observations will be used.\n- ddof : int, default 1\n- Delta Degrees of Freedom. The divisor used in calculations\n- is ``N - ddof``, where ``N`` represents the number of elements.\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- kwargs_numeric_only,\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- template_see_also[:-1],\n- window_method=\"rolling\",\n- aggregation_description=\"sample covariance\",\n- agg_method=\"cov\",\n- )\n- def cov(\n- self,\n- other: DataFrame | Series | None = None,\n- pairwise: bool | None = None,\n- ddof: int = 1,\n- numeric_only: bool = False,\n- **kwargs,\n- ):\n- return super().cov(\n- other=other,\n- pairwise=pairwise,\n- ddof=ddof,\n- numeric_only=numeric_only,\n- **kwargs,\n- )\n-\n- @doc(\n- template_header,\n- create_section_header(\"Parameters\"),\n- dedent(\n- \"\"\"\n- other : Series or DataFrame, optional\n- If not supplied then will default to self and produce pairwise\n- output.\n- pairwise : bool, default None\n- If False then only matching columns between self and other will be\n- used and the output will be a DataFrame.\n- If True then all pairwise combinations will be calculated and the\n- output will be a MultiIndexed DataFrame in the case of DataFrame\n- inputs. In the case of missing elements, only complete pairwise\n- observations will be used.\n- ddof : int, default 1\n- Delta Degrees of Freedom. The divisor used in calculations\n- is ``N - ddof``, where ``N`` represents the number of elements.\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- kwargs_numeric_only,\n- kwargs_compat,\n- create_section_header(\"Returns\"),\n- template_returns,\n- create_section_header(\"See Also\"),\n- dedent(\n- \"\"\"\n- cov : Similar method to calculate covariance.\n- numpy.corrcoef : NumPy Pearson's correlation calculation.\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- template_see_also,\n- create_section_header(\"Notes\"),\n- dedent(\n- \"\"\"\n- This function uses Pearson's definition of correlation\n- (https://en.wikipedia.org/wiki/Pearson_correlation_coefficient).\n-\n- When `other` is not specified, the output will be self correlation (e.g.\n- all 1's), except for :class:`~pandas.DataFrame` inputs with `pairwise`\n- set to `True`.\n-\n- Function will return ``NaN`` for correlations of equal valued sequences;\n- this is the result of a 0/0 division error.\n-\n- When `pairwise` is set to `False`, only matching columns between `self` and\n- `other` will be used.\n-\n- When `pairwise` is set to `True`, the output will be a MultiIndex DataFrame\n- with the original index on the first level, and the `other` DataFrame\n- columns on the second level.\n-\n- In the case of missing elements, only complete pairwise observations\n- will be used.\\n\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- create_section_header(\"Examples\"),\n- dedent(\n- \"\"\"\n- The below example shows a rolling calculation with a window size of\n- four matching the equivalent function call using :meth:`numpy.corrcoef`.\n-\n- >>> v1 = [3, 3, 3, 5, 8]\n- >>> v2 = [3, 4, 4, 4, 8]\n- >>> # numpy returns a 2X2 array, the correlation coefficient\n- >>> # is the number at entry [0][1]\n- >>> print(f\"{{np.corrcoef(v1[:-1], v2[:-1])[0][1]:.6f}}\")\n- 0.333333\n- >>> print(f\"{{np.corrcoef(v1[1:], v2[1:])[0][1]:.6f}}\")\n- 0.916949\n- >>> s1 = pd.Series(v1)\n- >>> s2 = pd.Series(v2)\n- >>> s1.rolling(4).corr(s2)\n- 0 NaN\n- 1 NaN\n- 2 NaN\n- 3 0.333333\n- 4 0.916949\n- dtype: float64\n-\n- The below example shows a similar rolling calculation on a\n- DataFrame using the pairwise option.\n-\n- >>> matrix = np.array([[51., 35.], [49., 30.], [47., 32.],\\\n- [46., 31.], [50., 36.]])\n- >>> print(np.corrcoef(matrix[:-1,0], matrix[:-1,1]).round(7))\n- [[1. 0.6263001]\n- [0.6263001 1. ]]\n- >>> print(np.corrcoef(matrix[1:,0], matrix[1:,1]).round(7))\n- [[1. 0.5553681]\n- [0.5553681 1. ]]\n- >>> df = pd.DataFrame(matrix, columns=['X','Y'])\n- >>> df\n- X Y\n- 0 51.0 35.0\n- 1 49.0 30.0\n- 2 47.0 32.0\n- 3 46.0 31.0\n- 4 50.0 36.0\n- >>> df.rolling(4).corr(pairwise=True)\n- X Y\n- 0 X NaN NaN\n- Y NaN NaN\n- 1 X NaN NaN\n- Y NaN NaN\n- 2 X NaN NaN\n- Y NaN NaN\n- 3 X 1.000000 0.626300\n- Y 0.626300 1.000000\n- 4 X 1.000000 0.555368\n- Y 0.555368 1.000000\n- \"\"\"\n- ).replace(\"\\n\", \"\", 1),\n- window_method=\"rolling\",\n- aggregation_description=\"correlation\",\n- agg_method=\"corr\",\n- )\n- def corr(\n- self,\n- other: DataFrame | Series | None = None,\n- pairwise: bool | None = None,\n- ddof: int = 1,\n- numeric_only: bool = False,\n- **kwargs,\n- ):\n- return super().corr(\n- other=other,\n- pairwise=pairwise,\n- ddof=ddof,\n- numeric_only=numeric_only,\n- **kwargs,\n- )\n-\n-\n-Rolling.__doc__ = Window.__doc__\n-\n-\n-class RollingGroupby(BaseWindowGroupby, Rolling):\n- \"\"\"\n- Provide a rolling groupby implementation.\n- \"\"\"\n-\n- _attributes = Rolling._attributes + BaseWindowGroupby._attributes\n-\n- def _get_window_indexer(self) -> GroupbyIndexer:\n- \"\"\"\n- Return an indexer class that will compute the window start and end bounds\n-\n- Returns\n- -------\n- GroupbyIndexer\n- \"\"\"\n- rolling_indexer: type[BaseIndexer]\n- indexer_kwargs: dict[str, Any] | None = None\n- index_array = self._index_array\n- if isinstance(self.window, BaseIndexer):\n- rolling_indexer = type(self.window)\n- indexer_kwargs = self.window.__dict__.copy()\n- assert isinstance(indexer_kwargs, dict) # for mypy\n- # We'll be using the index of each group later\n- indexer_kwargs.pop(\"index_array\", None)\n- window = self.window\n- elif self._win_freq_i8 is not None:\n- rolling_indexer = VariableWindowIndexer\n- window = self._win_freq_i8\n- else:\n- rolling_indexer = FixedWindowIndexer\n- window = self.window\n- window_indexer = GroupbyIndexer(\n- index_array=index_array,\n- window_size=window,\n- groupby_indices=self._grouper.indices,\n- window_indexer=rolling_indexer,\n- indexer_kwargs=indexer_kwargs,\n- )\n- return window_indexer\n-\n- def _validate_datetimelike_monotonic(self):\n- \"\"\"\n- Validate that each group in self._on is monotonic\n- \"\"\"\n- # GH 46061\n- if self._on.hasnans:\n- self._raise_monotonic_error(\"values must not have NaT\")\n- for group_indices in self._grouper.indices.values():\n- group_on = self._on.take(group_indices)\n- if not (\n- group_on.is_monotonic_increasing or group_on.is_monotonic_decreasing\n- ):\n- on = \"index\" if self.on is None else self.on\n- raise ValueError(\n- f\"Each group within {on} must be monotonic. \"\n- f\"Sort the values in {on} first.\"\n- )\n+from pandas._core.window.rolling import *\ndiff --git a/pandas/io/clipboards.py b/pandas/io/clipboards.py\nindex 0968f1facf128..496ab78c38b41 100644\n--- a/pandas/io/clipboards.py\n+++ b/pandas/io/clipboards.py\n@@ -4,7 +4,7 @@\n from io import StringIO\n import warnings\n \n-from pandas.core.dtypes.generic import ABCDataFrame\n+from pandas._core.dtypes.generic import ABCDataFrame\n \n from pandas import (\n get_option,\ndiff --git a/pandas/io/common.py b/pandas/io/common.py\nindex d692f26ab0576..1a30add07f070 100644\n--- a/pandas/io/common.py\n+++ b/pandas/io/common.py\n@@ -59,14 +59,14 @@\n from pandas.util._decorators import doc\n from pandas.util._exceptions import find_stack_level\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_bool,\n is_file_like,\n is_integer,\n is_list_like,\n )\n \n-from pandas.core.shared_docs import _shared_docs\n+from pandas._core.shared_docs import _shared_docs\n \n _VALID_URLS = set(uses_relative + uses_netloc + uses_params)\n _VALID_URLS.discard(\"\")\ndiff --git a/pandas/io/excel/_base.py b/pandas/io/excel/_base.py\nindex 24b881bda4805..019ed982ef7cc 100644\n--- a/pandas/io/excel/_base.py\n+++ b/pandas/io/excel/_base.py\n@@ -46,15 +46,15 @@\n )\n from pandas.util._exceptions import find_stack_level\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_bool,\n is_float,\n is_integer,\n is_list_like,\n )\n \n-from pandas.core.frame import DataFrame\n-from pandas.core.shared_docs import _shared_docs\n+from pandas._core.frame import DataFrame\n+from pandas._core.shared_docs import _shared_docs\n from pandas.util.version import Version\n \n from pandas.io.common import (\ndiff --git a/pandas/io/excel/_odfreader.py b/pandas/io/excel/_odfreader.py\nindex 075590f3535fe..539829663298d 100644\n--- a/pandas/io/excel/_odfreader.py\n+++ b/pandas/io/excel/_odfreader.py\n@@ -17,7 +17,7 @@\n from pandas.util._decorators import doc\n \n import pandas as pd\n-from pandas.core.shared_docs import _shared_docs\n+from pandas._core.shared_docs import _shared_docs\n \n from pandas.io.excel._base import BaseExcelReader\n \ndiff --git a/pandas/io/excel/_openpyxl.py b/pandas/io/excel/_openpyxl.py\nindex 87cc07d3fd21d..c4e2b44b66ff1 100644\n--- a/pandas/io/excel/_openpyxl.py\n+++ b/pandas/io/excel/_openpyxl.py\n@@ -20,7 +20,7 @@\n from pandas.compat._optional import import_optional_dependency\n from pandas.util._decorators import doc\n \n-from pandas.core.shared_docs import _shared_docs\n+from pandas._core.shared_docs import _shared_docs\n \n from pandas.io.excel._base import (\n BaseExcelReader,\ndiff --git a/pandas/io/excel/_pyxlsb.py b/pandas/io/excel/_pyxlsb.py\nindex 5d40ccdf2f8f3..e6433f9fde5e1 100644\n--- a/pandas/io/excel/_pyxlsb.py\n+++ b/pandas/io/excel/_pyxlsb.py\n@@ -10,7 +10,7 @@\n from pandas.compat._optional import import_optional_dependency\n from pandas.util._decorators import doc\n \n-from pandas.core.shared_docs import _shared_docs\n+from pandas._core.shared_docs import _shared_docs\n \n from pandas.io.excel._base import BaseExcelReader\n \ndiff --git a/pandas/io/excel/_util.py b/pandas/io/excel/_util.py\nindex c315657170a97..2e2843cf35275 100644\n--- a/pandas/io/excel/_util.py\n+++ b/pandas/io/excel/_util.py\n@@ -15,7 +15,7 @@\n \n from pandas.compat._optional import import_optional_dependency\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_integer,\n is_list_like,\n )\ndiff --git a/pandas/io/excel/_xlrd.py b/pandas/io/excel/_xlrd.py\nindex 0bf3ac6134cf6..d9ba28138908e 100644\n--- a/pandas/io/excel/_xlrd.py\n+++ b/pandas/io/excel/_xlrd.py\n@@ -11,7 +11,7 @@\n from pandas.compat._optional import import_optional_dependency\n from pandas.util._decorators import doc\n \n-from pandas.core.shared_docs import _shared_docs\n+from pandas._core.shared_docs import _shared_docs\n \n from pandas.io.excel._base import BaseExcelReader\n \ndiff --git a/pandas/io/feather_format.py b/pandas/io/feather_format.py\nindex 9813b91419060..33d6e45078430 100644\n--- a/pandas/io/feather_format.py\n+++ b/pandas/io/feather_format.py\n@@ -15,12 +15,12 @@\n from pandas.compat._optional import import_optional_dependency\n from pandas.util._decorators import doc\n \n-from pandas.core.api import (\n+from pandas._core.api import (\n DataFrame,\n Int64Index,\n RangeIndex,\n )\n-from pandas.core.shared_docs import _shared_docs\n+from pandas._core.shared_docs import _shared_docs\n \n from pandas.io.common import get_handle\n \ndiff --git a/pandas/io/formats/csvs.py b/pandas/io/formats/csvs.py\nindex c577acfaeba8e..ac6a06f9e274f 100644\n--- a/pandas/io/formats/csvs.py\n+++ b/pandas/io/formats/csvs.py\n@@ -28,15 +28,15 @@\n )\n from pandas.util._decorators import cache_readonly\n \n-from pandas.core.dtypes.generic import (\n+from pandas._core.dtypes.generic import (\n ABCDatetimeIndex,\n ABCIndex,\n ABCMultiIndex,\n ABCPeriodIndex,\n )\n-from pandas.core.dtypes.missing import notna\n+from pandas._core.dtypes.missing import notna\n \n-from pandas.core.indexes.api import Index\n+from pandas._core.indexes.api import Index\n \n from pandas.io.common import get_handle\n \ndiff --git a/pandas/io/formats/excel.py b/pandas/io/formats/excel.py\nindex effb0652aa2d3..d66fbeb45a6ef 100644\n--- a/pandas/io/formats/excel.py\n+++ b/pandas/io/formats/excel.py\n@@ -26,8 +26,8 @@\n )\n from pandas.util._decorators import doc\n \n-from pandas.core.dtypes import missing\n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes import missing\n+from pandas._core.dtypes.common import (\n is_float,\n is_scalar,\n )\n@@ -38,8 +38,8 @@\n MultiIndex,\n PeriodIndex,\n )\n-import pandas.core.common as com\n-from pandas.core.shared_docs import _shared_docs\n+import pandas._core.common as com\n+from pandas._core.shared_docs import _shared_docs\n \n from pandas.io.formats._color_data import CSS4_COLORS\n from pandas.io.formats.css import (\ndiff --git a/pandas/io/formats/format.py b/pandas/io/formats/format.py\nindex cf5e35f6ddcd1..60c09b2c76445 100644\n--- a/pandas/io/formats/format.py\n+++ b/pandas/io/formats/format.py\n@@ -61,7 +61,7 @@\n )\n from pandas.util._decorators import deprecate_kwarg\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_categorical_dtype,\n is_complex_dtype,\n is_datetime64_dtype,\n@@ -76,28 +76,28 @@\n is_scalar,\n is_timedelta64_dtype,\n )\n-from pandas.core.dtypes.missing import (\n+from pandas._core.dtypes.missing import (\n isna,\n notna,\n )\n \n-from pandas.core.arrays import (\n+from pandas._core.arrays import (\n Categorical,\n DatetimeArray,\n TimedeltaArray,\n )\n-from pandas.core.base import PandasObject\n-import pandas.core.common as com\n-from pandas.core.construction import extract_array\n-from pandas.core.indexes.api import (\n+from pandas._core.base import PandasObject\n+import pandas._core.common as com\n+from pandas._core.construction import extract_array\n+from pandas._core.indexes.api import (\n Index,\n MultiIndex,\n PeriodIndex,\n ensure_index,\n )\n-from pandas.core.indexes.datetimes import DatetimeIndex\n-from pandas.core.indexes.timedeltas import TimedeltaIndex\n-from pandas.core.reshape.concat import concat\n+from pandas._core.indexes.datetimes import DatetimeIndex\n+from pandas._core.indexes.timedeltas import TimedeltaIndex\n+from pandas._core.reshape.concat import concat\n \n from pandas.io.common import (\n check_parent_directory,\n@@ -912,7 +912,7 @@ def _get_formatter(self, i: str | int) -> Callable | None:\n return self.formatters.get(i, None)\n \n def _get_formatted_column_labels(self, frame: DataFrame) -> list[list[str]]:\n- from pandas.core.indexes.multi import sparsify_labels\n+ from pandas._core.indexes.multi import sparsify_labels\n \n columns = frame.columns\n \ndiff --git a/pandas/io/formats/info.py b/pandas/io/formats/info.py\nindex c0bdf37e5273a..cf451da294f84 100644\n--- a/pandas/io/formats/info.py\n+++ b/pandas/io/formats/info.py\n@@ -21,13 +21,13 @@\n WriteBuffer,\n )\n \n-from pandas.core.indexes.api import Index\n+from pandas._core.indexes.api import Index\n \n from pandas.io.formats import format as fmt\n from pandas.io.formats.printing import pprint_thing\n \n if TYPE_CHECKING:\n- from pandas.core.frame import (\n+ from pandas._core.frame import (\n DataFrame,\n Series,\n )\n@@ -567,7 +567,7 @@ def dtypes(self) -> Iterable[Dtype]:\n \n @property\n def dtype_counts(self):\n- from pandas.core.frame import DataFrame\n+ from pandas._core.frame import DataFrame\n \n return _get_dataframe_dtype_counts(DataFrame(self.data))\n \ndiff --git a/pandas/io/formats/latex.py b/pandas/io/formats/latex.py\nindex 0fb6971018fd0..97ddda1ac03bf 100644\n--- a/pandas/io/formats/latex.py\n+++ b/pandas/io/formats/latex.py\n@@ -14,7 +14,7 @@\n \n import numpy as np\n \n-from pandas.core.dtypes.generic import ABCMultiIndex\n+from pandas._core.dtypes.generic import ABCMultiIndex\n \n from pandas.io.formats.format import DataFrameFormatter\n \ndiff --git a/pandas/io/formats/printing.py b/pandas/io/formats/printing.py\nindex 77431533e703a..fe3a76db81abc 100644\n--- a/pandas/io/formats/printing.py\n+++ b/pandas/io/formats/printing.py\n@@ -17,7 +17,7 @@\n \n from pandas._config import get_option\n \n-from pandas.core.dtypes.inference import is_sequence\n+from pandas._core.dtypes.inference import is_sequence\n \n EscapeChars = Union[Mapping[str, str], Iterable[str]]\n _KT = TypeVar(\"_KT\")\ndiff --git a/pandas/io/formats/style.py b/pandas/io/formats/style.py\nindex 24669e84443a6..790ef23e358e7 100644\n--- a/pandas/io/formats/style.py\n+++ b/pandas/io/formats/style.py\n@@ -41,13 +41,13 @@\n IndexSlice,\n RangeIndex,\n )\n-import pandas.core.common as com\n-from pandas.core.frame import (\n+import pandas._core.common as com\n+from pandas._core.frame import (\n DataFrame,\n Series,\n )\n-from pandas.core.generic import NDFrame\n-from pandas.core.shared_docs import _shared_docs\n+from pandas._core.generic import NDFrame\n+from pandas._core.shared_docs import _shared_docs\n \n from pandas.io.formats.format import save_to_buffer\n \ndiff --git a/pandas/io/formats/style_render.py b/pandas/io/formats/style_render.py\nindex 65720e675a77a..f111d795e9e3a 100644\n--- a/pandas/io/formats/style_render.py\n+++ b/pandas/io/formats/style_render.py\n@@ -25,12 +25,12 @@\n from pandas._typing import Level\n from pandas.compat._optional import import_optional_dependency\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_complex,\n is_float,\n is_integer,\n )\n-from pandas.core.dtypes.generic import ABCSeries\n+from pandas._core.dtypes.generic import ABCSeries\n \n from pandas import (\n DataFrame,\n@@ -40,8 +40,8 @@\n Series,\n isna,\n )\n+import pandas._core.common as com\n from pandas.api.types import is_list_like\n-import pandas.core.common as com\n \n jinja2 = import_optional_dependency(\"jinja2\", extra=\"DataFrame.style requires jinja2.\")\n from markupsafe import escape as escape_html # markupsafe is jinja2 dependency\ndiff --git a/pandas/io/formats/xml.py b/pandas/io/formats/xml.py\nindex 4e8573b74ccdd..1393b796da9a1 100644\n--- a/pandas/io/formats/xml.py\n+++ b/pandas/io/formats/xml.py\n@@ -17,11 +17,11 @@\n from pandas.errors import AbstractMethodError\n from pandas.util._decorators import doc\n \n-from pandas.core.dtypes.common import is_list_like\n-from pandas.core.dtypes.missing import isna\n+from pandas._core.dtypes.common import is_list_like\n+from pandas._core.dtypes.missing import isna\n \n-from pandas.core.frame import DataFrame\n-from pandas.core.shared_docs import _shared_docs\n+from pandas._core.frame import DataFrame\n+from pandas._core.shared_docs import _shared_docs\n \n from pandas.io.common import get_handle\n from pandas.io.xml import (\ndiff --git a/pandas/io/html.py b/pandas/io/html.py\nindex ad92bb2447329..074ce0a08421f 100644\n--- a/pandas/io/html.py\n+++ b/pandas/io/html.py\n@@ -26,10 +26,10 @@\n )\n from pandas.util._decorators import deprecate_nonkeyword_arguments\n \n-from pandas.core.dtypes.common import is_list_like\n+from pandas._core.dtypes.common import is_list_like\n \n-from pandas.core.construction import create_series_with_explicit_dtype\n-from pandas.core.frame import DataFrame\n+from pandas._core.construction import create_series_with_explicit_dtype\n+from pandas._core.frame import DataFrame\n \n from pandas.io.common import (\n file_exists,\ndiff --git a/pandas/io/json/_json.py b/pandas/io/json/_json.py\nindex fbea7a71202eb..91f040f1b552a 100644\n--- a/pandas/io/json/_json.py\n+++ b/pandas/io/json/_json.py\n@@ -32,7 +32,7 @@\n doc,\n )\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n ensure_str,\n is_period_dtype,\n )\n@@ -45,10 +45,10 @@\n notna,\n to_datetime,\n )\n-from pandas.core.construction import create_series_with_explicit_dtype\n-from pandas.core.generic import NDFrame\n-from pandas.core.reshape.concat import concat\n-from pandas.core.shared_docs import _shared_docs\n+from pandas._core.construction import create_series_with_explicit_dtype\n+from pandas._core.generic import NDFrame\n+from pandas._core.reshape.concat import concat\n+from pandas._core.shared_docs import _shared_docs\n \n from pandas.io.common import (\n IOHandles,\ndiff --git a/pandas/io/json/_table_schema.py b/pandas/io/json/_table_schema.py\nindex c630f0d7613e0..bb4c9e67fe108 100644\n--- a/pandas/io/json/_table_schema.py\n+++ b/pandas/io/json/_table_schema.py\n@@ -18,8 +18,8 @@\n JSONSerializable,\n )\n \n-from pandas.core.dtypes.base import _registry as registry\n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.base import _registry as registry\n+from pandas._core.dtypes.common import (\n is_bool_dtype,\n is_categorical_dtype,\n is_datetime64_dtype,\n@@ -31,14 +31,14 @@\n is_string_dtype,\n is_timedelta64_dtype,\n )\n-from pandas.core.dtypes.dtypes import CategoricalDtype\n+from pandas._core.dtypes.dtypes import CategoricalDtype\n \n from pandas import DataFrame\n-import pandas.core.common as com\n+import pandas._core.common as com\n \n if TYPE_CHECKING:\n from pandas import Series\n- from pandas.core.indexes.multi import MultiIndex\n+ from pandas._core.indexes.multi import MultiIndex\n \n loads = json.loads\n \ndiff --git a/pandas/io/orc.py b/pandas/io/orc.py\nindex 40754a56bbe8b..aa8e0eaf7011f 100644\n--- a/pandas/io/orc.py\n+++ b/pandas/io/orc.py\n@@ -16,7 +16,7 @@\n )\n from pandas.compat._optional import import_optional_dependency\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_categorical_dtype,\n is_interval_dtype,\n is_period_dtype,\ndiff --git a/pandas/io/parquet.py b/pandas/io/parquet.py\nindex cbf3bcc9278d5..e9020084953fc 100644\n--- a/pandas/io/parquet.py\n+++ b/pandas/io/parquet.py\n@@ -21,7 +21,7 @@\n MultiIndex,\n get_option,\n )\n-from pandas.core.shared_docs import _shared_docs\n+from pandas._core.shared_docs import _shared_docs\n from pandas.util.version import Version\n \n from pandas.io.common import (\n@@ -151,7 +151,7 @@ def __init__(self) -> None:\n import pyarrow.parquet\n \n # import utils to register the pyarrow extension types\n- import pandas.core.arrays.arrow._arrow_utils # noqa:F401\n+ import pandas._core.arrays.arrow._arrow_utils # noqa:F401\n \n self.api = pyarrow\n \ndiff --git a/pandas/io/parsers/arrow_parser_wrapper.py b/pandas/io/parsers/arrow_parser_wrapper.py\nindex 21e8bb5f9e89f..6931af8247b19 100644\n--- a/pandas/io/parsers/arrow_parser_wrapper.py\n+++ b/pandas/io/parsers/arrow_parser_wrapper.py\n@@ -3,9 +3,9 @@\n from pandas._typing import ReadBuffer\n from pandas.compat._optional import import_optional_dependency\n \n-from pandas.core.dtypes.inference import is_integer\n+from pandas._core.dtypes.inference import is_integer\n \n-from pandas.core.frame import DataFrame\n+from pandas._core.frame import DataFrame\n \n from pandas.io.parsers.base_parser import ParserBase\n \ndiff --git a/pandas/io/parsers/base_parser.py b/pandas/io/parsers/base_parser.py\nindex cdd24a1194a45..71d5e1eab15f8 100644\n--- a/pandas/io/parsers/base_parser.py\n+++ b/pandas/io/parsers/base_parser.py\n@@ -40,8 +40,8 @@\n )\n from pandas.util._exceptions import find_stack_level\n \n-from pandas.core.dtypes.astype import astype_nansafe\n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.astype import astype_nansafe\n+from pandas._core.dtypes.common import (\n ensure_object,\n is_bool_dtype,\n is_categorical_dtype,\n@@ -56,19 +56,19 @@\n is_string_dtype,\n pandas_dtype,\n )\n-from pandas.core.dtypes.dtypes import CategoricalDtype\n-from pandas.core.dtypes.missing import isna\n+from pandas._core.dtypes.dtypes import CategoricalDtype\n+from pandas._core.dtypes.missing import isna\n \n from pandas import DataFrame\n-from pandas.core import algorithms\n-from pandas.core.arrays import Categorical\n-from pandas.core.indexes.api import (\n+from pandas._core import algorithms\n+from pandas._core.arrays import Categorical\n+from pandas._core.indexes.api import (\n Index,\n MultiIndex,\n ensure_index_from_sequences,\n )\n-from pandas.core.series import Series\n-from pandas.core.tools import datetimes as tools\n+from pandas._core.series import Series\n+from pandas._core.tools import datetimes as tools\n \n from pandas.io.date_converters import generic_parser\n \ndiff --git a/pandas/io/parsers/c_parser_wrapper.py b/pandas/io/parsers/c_parser_wrapper.py\nindex 3d6b5fcb49b85..c08865f7001d6 100644\n--- a/pandas/io/parsers/c_parser_wrapper.py\n+++ b/pandas/io/parsers/c_parser_wrapper.py\n@@ -21,18 +21,18 @@\n from pandas.errors import DtypeWarning\n from pandas.util._exceptions import find_stack_level\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_categorical_dtype,\n pandas_dtype,\n )\n-from pandas.core.dtypes.concat import union_categoricals\n-from pandas.core.dtypes.dtypes import ExtensionDtype\n+from pandas._core.dtypes.concat import union_categoricals\n+from pandas._core.dtypes.dtypes import ExtensionDtype\n \n from pandas import (\n Index,\n MultiIndex,\n )\n-from pandas.core.indexes.api import ensure_index_from_sequences\n+from pandas._core.indexes.api import ensure_index_from_sequences\n \n from pandas.io.parsers.base_parser import (\n ParserBase,\ndiff --git a/pandas/io/parsers/python_parser.py b/pandas/io/parsers/python_parser.py\nindex ec953c9df036c..63c36254f2a37 100644\n--- a/pandas/io/parsers/python_parser.py\n+++ b/pandas/io/parsers/python_parser.py\n@@ -35,8 +35,8 @@\n )\n from pandas.util._exceptions import find_stack_level\n \n-from pandas.core.dtypes.common import is_integer\n-from pandas.core.dtypes.inference import is_dict_like\n+from pandas._core.dtypes.common import is_integer\n+from pandas._core.dtypes.inference import is_dict_like\n \n from pandas import (\n Index,\ndiff --git a/pandas/io/parsers/readers.py b/pandas/io/parsers/readers.py\nindex 867cdf0ee7636..cd192e59ac395 100644\n--- a/pandas/io/parsers/readers.py\n+++ b/pandas/io/parsers/readers.py\n@@ -43,16 +43,16 @@\n from pandas.util._exceptions import find_stack_level\n from pandas.util._validators import validate_bool_kwarg\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_file_like,\n is_float,\n is_integer,\n is_list_like,\n )\n \n-from pandas.core.frame import DataFrame\n-from pandas.core.indexes.api import RangeIndex\n-from pandas.core.shared_docs import _shared_docs\n+from pandas._core.frame import DataFrame\n+from pandas._core.indexes.api import RangeIndex\n+from pandas._core.shared_docs import _shared_docs\n \n from pandas.io.common import (\n IOHandles,\ndiff --git a/pandas/io/pickle.py b/pandas/io/pickle.py\nindex 2928d8c6520b0..b145e66fe029a 100644\n--- a/pandas/io/pickle.py\n+++ b/pandas/io/pickle.py\n@@ -15,7 +15,7 @@\n from pandas.compat import pickle_compat as pc\n from pandas.util._decorators import doc\n \n-from pandas.core.shared_docs import _shared_docs\n+from pandas._core.shared_docs import _shared_docs\n \n from pandas.io.common import get_handle\n \n@@ -205,7 +205,7 @@ def read_pickle(\n return pickle.load(handles.handle)\n except excs_to_catch:\n # e.g.\n- # \"No module named 'pandas.core.sparse.series'\"\n+ # \"No module named 'pandas._core.sparse.series'\"\n # \"Can't get attribute '__nat_unpickle' on <module 'pandas._libs.tslib\"\n return pc.load(handles.handle, encoding=None)\n except UnicodeDecodeError:\ndiff --git a/pandas/io/pytables.py b/pandas/io/pytables.py\nindex c20ce0c847b61..8e3697d89f333 100644\n--- a/pandas/io/pytables.py\n+++ b/pandas/io/pytables.py\n@@ -50,7 +50,7 @@\n from pandas.util._decorators import cache_readonly\n from pandas.util._exceptions import find_stack_level\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n ensure_object,\n is_categorical_dtype,\n is_complex_dtype,\n@@ -62,7 +62,7 @@\n is_timedelta64_dtype,\n needs_i8_conversion,\n )\n-from pandas.core.dtypes.missing import array_equivalent\n+from pandas._core.dtypes.missing import array_equivalent\n \n from pandas import (\n DataFrame,\n@@ -75,20 +75,20 @@\n concat,\n isna,\n )\n-from pandas.core.api import Int64Index\n-from pandas.core.arrays import (\n+from pandas._core.api import Int64Index\n+from pandas._core.arrays import (\n Categorical,\n DatetimeArray,\n PeriodArray,\n )\n-import pandas.core.common as com\n-from pandas.core.computation.pytables import (\n+import pandas._core.common as com\n+from pandas._core.computation.pytables import (\n PyTablesExpr,\n maybe_expression,\n )\n-from pandas.core.construction import extract_array\n-from pandas.core.indexes.api import ensure_index\n-from pandas.core.internals import (\n+from pandas._core.construction import extract_array\n+from pandas._core.indexes.api import ensure_index\n+from pandas._core.internals import (\n ArrayManager,\n BlockManager,\n )\n@@ -106,7 +106,7 @@\n Node,\n )\n \n- from pandas.core.internals import Block\n+ from pandas._core.internals import Block\n \n \n # versioning attribute\ndiff --git a/pandas/io/sas/sasreader.py b/pandas/io/sas/sasreader.py\nindex 052e674d1a488..363020743fd8b 100644\n--- a/pandas/io/sas/sasreader.py\n+++ b/pandas/io/sas/sasreader.py\n@@ -23,7 +23,7 @@\n doc,\n )\n \n-from pandas.core.shared_docs import _shared_docs\n+from pandas._core.shared_docs import _shared_docs\n \n from pandas.io.common import stringify_path\n \ndiff --git a/pandas/io/spss.py b/pandas/io/spss.py\nindex 533cf7a7a6331..8232bb67335d1 100644\n--- a/pandas/io/spss.py\n+++ b/pandas/io/spss.py\n@@ -5,9 +5,9 @@\n \n from pandas.compat._optional import import_optional_dependency\n \n-from pandas.core.dtypes.inference import is_list_like\n+from pandas._core.dtypes.inference import is_list_like\n \n-from pandas.core.api import DataFrame\n+from pandas._core.api import DataFrame\n \n from pandas.io.common import stringify_path\n \ndiff --git a/pandas/io/sql.py b/pandas/io/sql.py\nindex 701642ad2cfe2..a4624ede7aaa6 100644\n--- a/pandas/io/sql.py\n+++ b/pandas/io/sql.py\n@@ -33,22 +33,22 @@\n from pandas.errors import AbstractMethodError\n from pandas.util._exceptions import find_stack_level\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_datetime64tz_dtype,\n is_dict_like,\n is_list_like,\n )\n-from pandas.core.dtypes.dtypes import DatetimeTZDtype\n-from pandas.core.dtypes.missing import isna\n+from pandas._core.dtypes.dtypes import DatetimeTZDtype\n+from pandas._core.dtypes.missing import isna\n \n from pandas import get_option\n-from pandas.core.api import (\n+from pandas._core.api import (\n DataFrame,\n Series,\n )\n-from pandas.core.base import PandasObject\n-import pandas.core.common as com\n-from pandas.core.tools.datetimes import to_datetime\n+from pandas._core.base import PandasObject\n+import pandas._core.common as com\n+from pandas._core.tools.datetimes import to_datetime\n \n \n class DatabaseError(OSError):\ndiff --git a/pandas/io/stata.py b/pandas/io/stata.py\nindex 1a230f4ae4164..601da6848e050 100644\n--- a/pandas/io/stata.py\n+++ b/pandas/io/stata.py\n@@ -45,7 +45,7 @@\n doc,\n )\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n ensure_object,\n is_categorical_dtype,\n is_datetime64_dtype,\n@@ -61,12 +61,12 @@\n to_datetime,\n to_timedelta,\n )\n-from pandas.core.arrays.boolean import BooleanDtype\n-from pandas.core.arrays.integer import IntegerDtype\n-from pandas.core.frame import DataFrame\n-from pandas.core.indexes.base import Index\n-from pandas.core.series import Series\n-from pandas.core.shared_docs import _shared_docs\n+from pandas._core.arrays.boolean import BooleanDtype\n+from pandas._core.arrays.integer import IntegerDtype\n+from pandas._core.frame import DataFrame\n+from pandas._core.indexes.base import Index\n+from pandas._core.series import Series\n+from pandas._core.shared_docs import _shared_docs\n \n from pandas.io.common import get_handle\n \ndiff --git a/pandas/io/xml.py b/pandas/io/xml.py\nindex 78fbeaad09300..f49494053915e 100644\n--- a/pandas/io/xml.py\n+++ b/pandas/io/xml.py\n@@ -30,10 +30,10 @@\n doc,\n )\n \n-from pandas.core.dtypes.common import is_list_like\n+from pandas._core.dtypes.common import is_list_like\n \n-from pandas.core.frame import DataFrame\n-from pandas.core.shared_docs import _shared_docs\n+from pandas._core.frame import DataFrame\n+from pandas._core.shared_docs import _shared_docs\n \n from pandas.io.common import (\n file_exists,\ndiff --git a/pandas/plotting/_core.py b/pandas/plotting/_core.py\nindex bc39d1f619f49..3cd505fce6a4e 100644\n--- a/pandas/plotting/_core.py\n+++ b/pandas/plotting/_core.py\n@@ -15,16 +15,16 @@\n Substitution,\n )\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_integer,\n is_list_like,\n )\n-from pandas.core.dtypes.generic import (\n+from pandas._core.dtypes.generic import (\n ABCDataFrame,\n ABCSeries,\n )\n \n-from pandas.core.base import PandasObject\n+from pandas._core.base import PandasObject\n \n if TYPE_CHECKING:\n from pandas import DataFrame\ndiff --git a/pandas/plotting/_matplotlib/boxplot.py b/pandas/plotting/_matplotlib/boxplot.py\nindex a49b035b1aaf1..3daed744a7635 100644\n--- a/pandas/plotting/_matplotlib/boxplot.py\n+++ b/pandas/plotting/_matplotlib/boxplot.py\n@@ -10,11 +10,11 @@\n from matplotlib.artist import setp\n import numpy as np\n \n-from pandas.core.dtypes.common import is_dict_like\n-from pandas.core.dtypes.missing import remove_na_arraylike\n+from pandas._core.dtypes.common import is_dict_like\n+from pandas._core.dtypes.missing import remove_na_arraylike\n \n import pandas as pd\n-import pandas.core.common as com\n+import pandas._core.common as com\n \n from pandas.io.formats.printing import pprint_thing\n from pandas.plotting._matplotlib.core import (\ndiff --git a/pandas/plotting/_matplotlib/converter.py b/pandas/plotting/_matplotlib/converter.py\nindex 31f014d25d67d..976bf910f9d7d 100644\n--- a/pandas/plotting/_matplotlib/converter.py\n+++ b/pandas/plotting/_matplotlib/converter.py\n@@ -33,7 +33,7 @@\n from pandas._libs.tslibs.offsets import BaseOffset\n from pandas._typing import F\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_float,\n is_float_dtype,\n is_integer,\n@@ -46,14 +46,14 @@\n Series,\n get_option,\n )\n-import pandas.core.common as com\n-from pandas.core.indexes.datetimes import date_range\n-from pandas.core.indexes.period import (\n+import pandas._core.common as com\n+from pandas._core.indexes.datetimes import date_range\n+from pandas._core.indexes.period import (\n Period,\n PeriodIndex,\n period_range,\n )\n-import pandas.core.tools.datetimes as tools\n+import pandas._core.tools.datetimes as tools\n \n # constants\n HOURS_PER_DAY = 24.0\ndiff --git a/pandas/plotting/_matplotlib/core.py b/pandas/plotting/_matplotlib/core.py\nindex 3641cd7213fec..7272d76cbd6c2 100644\n--- a/pandas/plotting/_matplotlib/core.py\n+++ b/pandas/plotting/_matplotlib/core.py\n@@ -23,7 +23,7 @@\n from pandas.errors import AbstractMethodError\n from pandas.util._decorators import cache_readonly\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_categorical_dtype,\n is_extension_array_dtype,\n is_float,\n@@ -36,20 +36,20 @@\n is_number,\n is_numeric_dtype,\n )\n-from pandas.core.dtypes.generic import (\n+from pandas._core.dtypes.generic import (\n ABCDataFrame,\n ABCIndex,\n ABCMultiIndex,\n ABCPeriodIndex,\n ABCSeries,\n )\n-from pandas.core.dtypes.missing import (\n+from pandas._core.dtypes.missing import (\n isna,\n notna,\n )\n \n-import pandas.core.common as com\n-from pandas.core.frame import DataFrame\n+import pandas._core.common as com\n+from pandas._core.frame import DataFrame\n \n from pandas.io.formats.printing import pprint_thing\n from pandas.plotting._matplotlib.converter import register_pandas_matplotlib_converters\ndiff --git a/pandas/plotting/_matplotlib/groupby.py b/pandas/plotting/_matplotlib/groupby.py\nindex 1b16eefb360ae..4b42ff7662fa9 100644\n--- a/pandas/plotting/_matplotlib/groupby.py\n+++ b/pandas/plotting/_matplotlib/groupby.py\n@@ -7,7 +7,7 @@\n IndexLabel,\n )\n \n-from pandas.core.dtypes.missing import remove_na_arraylike\n+from pandas._core.dtypes.missing import remove_na_arraylike\n \n from pandas import (\n DataFrame,\ndiff --git a/pandas/plotting/_matplotlib/hist.py b/pandas/plotting/_matplotlib/hist.py\nindex 77496cf049f3d..e141e4350aa70 100644\n--- a/pandas/plotting/_matplotlib/hist.py\n+++ b/pandas/plotting/_matplotlib/hist.py\n@@ -9,20 +9,20 @@\n \n from pandas._typing import PlottingOrientation\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_integer,\n is_list_like,\n )\n-from pandas.core.dtypes.generic import (\n+from pandas._core.dtypes.generic import (\n ABCDataFrame,\n ABCIndex,\n )\n-from pandas.core.dtypes.missing import (\n+from pandas._core.dtypes.missing import (\n isna,\n remove_na_arraylike,\n )\n \n-from pandas.core.frame import DataFrame\n+from pandas._core.frame import DataFrame\n \n from pandas.io.formats.printing import pprint_thing\n from pandas.plotting._matplotlib.core import (\ndiff --git a/pandas/plotting/_matplotlib/misc.py b/pandas/plotting/_matplotlib/misc.py\nindex 083d85ef0876d..0d0799994e3ba 100644\n--- a/pandas/plotting/_matplotlib/misc.py\n+++ b/pandas/plotting/_matplotlib/misc.py\n@@ -10,7 +10,7 @@\n import matplotlib.patches as patches\n import numpy as np\n \n-from pandas.core.dtypes.missing import notna\n+from pandas._core.dtypes.missing import notna\n \n from pandas.io.formats.printing import pprint_thing\n from pandas.plotting._matplotlib.style import get_standard_colors\ndiff --git a/pandas/plotting/_matplotlib/style.py b/pandas/plotting/_matplotlib/style.py\nindex 9e459b82fec97..0fc6541077aca 100644\n--- a/pandas/plotting/_matplotlib/style.py\n+++ b/pandas/plotting/_matplotlib/style.py\n@@ -15,9 +15,9 @@\n import matplotlib.colors\n import numpy as np\n \n-from pandas.core.dtypes.common import is_list_like\n+from pandas._core.dtypes.common import is_list_like\n \n-import pandas.core.common as com\n+import pandas._core.common as com\n \n if TYPE_CHECKING:\n from matplotlib.colors import Colormap\ndiff --git a/pandas/plotting/_matplotlib/timeseries.py b/pandas/plotting/_matplotlib/timeseries.py\nindex ca6cccb0f98eb..1afc428af8948 100644\n--- a/pandas/plotting/_matplotlib/timeseries.py\n+++ b/pandas/plotting/_matplotlib/timeseries.py\n@@ -18,7 +18,7 @@\n )\n from pandas._libs.tslibs.dtypes import FreqGroup\n \n-from pandas.core.dtypes.generic import (\n+from pandas._core.dtypes.generic import (\n ABCDatetimeIndex,\n ABCPeriodIndex,\n ABCTimedeltaIndex,\ndiff --git a/pandas/plotting/_matplotlib/tools.py b/pandas/plotting/_matplotlib/tools.py\nindex 94357e5002ffd..c43b928ec94f9 100644\n--- a/pandas/plotting/_matplotlib/tools.py\n+++ b/pandas/plotting/_matplotlib/tools.py\n@@ -15,8 +15,8 @@\n \n from pandas.util._exceptions import find_stack_level\n \n-from pandas.core.dtypes.common import is_list_like\n-from pandas.core.dtypes.generic import (\n+from pandas._core.dtypes.common import is_list_like\n+from pandas._core.dtypes.generic import (\n ABCDataFrame,\n ABCIndex,\n ABCSeries,\ndiff --git a/pandas/tests/apply/common.py b/pandas/tests/apply/common.py\nindex 91b831bcbb684..6c48401fce201 100644\n--- a/pandas/tests/apply/common.py\n+++ b/pandas/tests/apply/common.py\n@@ -1,4 +1,4 @@\n-from pandas.core.groupby.base import transformation_kernels\n+from pandas._core.groupby.base import transformation_kernels\n \n # tshift only works on time index and is deprecated\n # There is no Series.cumcount or DataFrame.cumcount\ndiff --git a/pandas/tests/apply/test_frame_apply.py b/pandas/tests/apply/test_frame_apply.py\nindex ef7ab4a469865..4e8e952b99a17 100644\n--- a/pandas/tests/apply/test_frame_apply.py\n+++ b/pandas/tests/apply/test_frame_apply.py\n@@ -4,7 +4,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.dtypes import CategoricalDtype\n+from pandas._core.dtypes.dtypes import CategoricalDtype\n \n import pandas as pd\n from pandas import (\ndiff --git a/pandas/tests/apply/test_str.py b/pandas/tests/apply/test_str.py\nindex 2af063dee8b55..6d01a31a2654d 100644\n--- a/pandas/tests/apply/test_str.py\n+++ b/pandas/tests/apply/test_str.py\n@@ -4,15 +4,15 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import is_number\n+from pandas._core.dtypes.common import is_number\n \n from pandas import (\n DataFrame,\n Index,\n Series,\n )\n+from pandas._core.groupby.base import maybe_normalize_deprecated_kernels\n import pandas._testing as tm\n-from pandas.core.groupby.base import maybe_normalize_deprecated_kernels\n from pandas.tests.apply.common import (\n frame_transform_kernels,\n series_transform_kernels,\n@@ -134,7 +134,7 @@ def test_apply_np_transformer(float_frame, op, how):\n def test_agg_cython_table_series(series, func, expected):\n # GH21224\n # test reducing functions in\n- # pandas.core.base.SelectionMixin._cython_table\n+ # pandas._core.base.SelectionMixin._cython_table\n result = series.agg(func)\n if is_number(expected):\n assert np.isclose(result, expected, equal_nan=True)\n@@ -167,7 +167,7 @@ def test_agg_cython_table_series(series, func, expected):\n def test_agg_cython_table_transform_series(series, func, expected):\n # GH21224\n # test transforming functions in\n- # pandas.core.base.SelectionMixin._cython_table (cumprod, cumsum)\n+ # pandas._core.base.SelectionMixin._cython_table (cumprod, cumsum)\n result = series.agg(func)\n tm.assert_series_equal(result, expected)\n \n@@ -210,7 +210,7 @@ def test_agg_cython_table_transform_series(series, func, expected):\n def test_agg_cython_table_frame(df, func, expected, axis):\n # GH 21224\n # test reducing functions in\n- # pandas.core.base.SelectionMixin._cython_table\n+ # pandas._core.base.SelectionMixin._cython_table\n result = df.agg(func, axis=axis)\n tm.assert_series_equal(result, expected)\n \n@@ -233,7 +233,7 @@ def test_agg_cython_table_frame(df, func, expected, axis):\n def test_agg_cython_table_transform_frame(df, func, expected, axis):\n # GH 21224\n # test transforming functions in\n- # pandas.core.base.SelectionMixin._cython_table (cumprod, cumsum)\n+ # pandas._core.base.SelectionMixin._cython_table (cumprod, cumsum)\n if axis == \"columns\" or axis == 1:\n # operating blockwise doesn't let us preserve dtypes\n expected = expected.astype(\"float64\")\ndiff --git a/pandas/tests/arithmetic/common.py b/pandas/tests/arithmetic/common.py\nindex f3173e8f0eb57..13b21e5155a26 100644\n--- a/pandas/tests/arithmetic/common.py\n+++ b/pandas/tests/arithmetic/common.py\n@@ -10,11 +10,11 @@\n Series,\n array,\n )\n-import pandas._testing as tm\n-from pandas.core.arrays import (\n+from pandas._core.arrays import (\n BooleanArray,\n PandasArray,\n )\n+import pandas._testing as tm\n \n \n def assert_cannot_add(left, right, msg=\"cannot add\"):\ndiff --git a/pandas/tests/arithmetic/conftest.py b/pandas/tests/arithmetic/conftest.py\nindex e847f31cd3f9c..0a83abdad00a2 100644\n--- a/pandas/tests/arithmetic/conftest.py\n+++ b/pandas/tests/arithmetic/conftest.py\n@@ -3,13 +3,13 @@\n \n import pandas as pd\n from pandas import RangeIndex\n-import pandas._testing as tm\n-from pandas.core.api import (\n+from pandas._core.api import (\n Float64Index,\n Int64Index,\n UInt64Index,\n )\n-from pandas.core.computation import expressions as expr\n+from pandas._core.computation import expressions as expr\n+import pandas._testing as tm\n \n \n @pytest.fixture(\ndiff --git a/pandas/tests/arithmetic/test_array_ops.py b/pandas/tests/arithmetic/test_array_ops.py\nindex 2c347d965bbf7..2d0a7d873db18 100644\n--- a/pandas/tests/arithmetic/test_array_ops.py\n+++ b/pandas/tests/arithmetic/test_array_ops.py\n@@ -3,11 +3,11 @@\n import numpy as np\n import pytest\n \n-import pandas._testing as tm\n-from pandas.core.ops.array_ops import (\n+from pandas._core.ops.array_ops import (\n comparison_op,\n na_logical_op,\n )\n+import pandas._testing as tm\n \n \n def test_na_logical_op_2d():\ndiff --git a/pandas/tests/arithmetic/test_datetime64.py b/pandas/tests/arithmetic/test_datetime64.py\nindex 0b1d56a956c07..ece6f843bc6e2 100644\n--- a/pandas/tests/arithmetic/test_datetime64.py\n+++ b/pandas/tests/arithmetic/test_datetime64.py\n@@ -33,12 +33,12 @@\n Timestamp,\n date_range,\n )\n-import pandas._testing as tm\n-from pandas.core.arrays import (\n+from pandas._core.arrays import (\n DatetimeArray,\n TimedeltaArray,\n )\n-from pandas.core.ops import roperator\n+from pandas._core.ops import roperator\n+import pandas._testing as tm\n from pandas.tests.arithmetic.common import (\n assert_cannot_add,\n assert_invalid_addsub_type,\n@@ -1108,7 +1108,7 @@ def test_dt64arr_addsub_intlike(\n assert_invalid_addsub_type(obj, pd.array(other), msg)\n assert_invalid_addsub_type(obj, pd.Categorical(other), msg)\n assert_invalid_addsub_type(obj, pd.Index(other), msg)\n- assert_invalid_addsub_type(obj, pd.core.indexes.api.NumericIndex(other), msg)\n+ assert_invalid_addsub_type(obj, pd._core.indexes.api.NumericIndex(other), msg)\n assert_invalid_addsub_type(obj, Series(other), msg)\n \n @pytest.mark.parametrize(\ndiff --git a/pandas/tests/arithmetic/test_interval.py b/pandas/tests/arithmetic/test_interval.py\nindex 99e1ad1767e07..0327bbfd16e6d 100644\n--- a/pandas/tests/arithmetic/test_interval.py\n+++ b/pandas/tests/arithmetic/test_interval.py\n@@ -3,7 +3,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import is_list_like\n+from pandas._core.dtypes.common import is_list_like\n \n import pandas as pd\n from pandas import (\n@@ -19,11 +19,11 @@\n period_range,\n timedelta_range,\n )\n-import pandas._testing as tm\n-from pandas.core.arrays import (\n+from pandas._core.arrays import (\n BooleanArray,\n IntervalArray,\n )\n+import pandas._testing as tm\n from pandas.tests.arithmetic.common import get_upcast_box\n \n \ndiff --git a/pandas/tests/arithmetic/test_numeric.py b/pandas/tests/arithmetic/test_numeric.py\nindex 881a5f1de1c60..16797a45b2220 100644\n--- a/pandas/tests/arithmetic/test_numeric.py\n+++ b/pandas/tests/arithmetic/test_numeric.py\n@@ -20,14 +20,14 @@\n TimedeltaIndex,\n array,\n )\n-import pandas._testing as tm\n-from pandas.core import ops\n-from pandas.core.api import (\n+from pandas._core import ops\n+from pandas._core.api import (\n Float64Index,\n Int64Index,\n UInt64Index,\n )\n-from pandas.core.computation import expressions as expr\n+from pandas._core.computation import expressions as expr\n+import pandas._testing as tm\n from pandas.tests.arithmetic.common import (\n assert_invalid_addsub_type,\n assert_invalid_comparison,\ndiff --git a/pandas/tests/arithmetic/test_object.py b/pandas/tests/arithmetic/test_object.py\nindex e107ff6b65c0f..f7d9b8173d00f 100644\n--- a/pandas/tests/arithmetic/test_object.py\n+++ b/pandas/tests/arithmetic/test_object.py\n@@ -13,8 +13,8 @@\n Series,\n Timestamp,\n )\n+from pandas._core import ops\n import pandas._testing as tm\n-from pandas.core import ops\n \n # ------------------------------------------------------------------\n # Comparisons\ndiff --git a/pandas/tests/arithmetic/test_period.py b/pandas/tests/arithmetic/test_period.py\nindex 7adc407fd5de1..185dfdb9372f7 100644\n--- a/pandas/tests/arithmetic/test_period.py\n+++ b/pandas/tests/arithmetic/test_period.py\n@@ -22,9 +22,9 @@\n TimedeltaIndex,\n period_range,\n )\n+from pandas._core import ops\n+from pandas._core.arrays import TimedeltaArray\n import pandas._testing as tm\n-from pandas.core import ops\n-from pandas.core.arrays import TimedeltaArray\n from pandas.tests.arithmetic.common import (\n assert_invalid_addsub_type,\n assert_invalid_comparison,\ndiff --git a/pandas/tests/arithmetic/test_timedelta64.py b/pandas/tests/arithmetic/test_timedelta64.py\nindex bb7949c9f08e2..5241b13f263f7 100644\n--- a/pandas/tests/arithmetic/test_timedelta64.py\n+++ b/pandas/tests/arithmetic/test_timedelta64.py\n@@ -25,12 +25,12 @@\n offsets,\n timedelta_range,\n )\n-import pandas._testing as tm\n-from pandas.core.api import (\n+from pandas._core.api import (\n Float64Index,\n Int64Index,\n UInt64Index,\n )\n+import pandas._testing as tm\n from pandas.tests.arithmetic.common import (\n assert_invalid_addsub_type,\n assert_invalid_comparison,\ndiff --git a/pandas/tests/arrays/boolean/test_construction.py b/pandas/tests/arrays/boolean/test_construction.py\nindex d26eea19c06e9..4fb9f455f89dc 100644\n--- a/pandas/tests/arrays/boolean/test_construction.py\n+++ b/pandas/tests/arrays/boolean/test_construction.py\n@@ -2,9 +2,9 @@\n import pytest\n \n import pandas as pd\n+from pandas._core.arrays.boolean import coerce_to_array\n import pandas._testing as tm\n from pandas.arrays import BooleanArray\n-from pandas.core.arrays.boolean import coerce_to_array\n \n \n def test_boolean_array_constructor():\ndiff --git a/pandas/tests/arrays/boolean/test_function.py b/pandas/tests/arrays/boolean/test_function.py\nindex 8e9112b531fad..187a311cf4ea9 100644\n--- a/pandas/tests/arrays/boolean/test_function.py\n+++ b/pandas/tests/arrays/boolean/test_function.py\n@@ -114,7 +114,7 @@ def test_diff():\n a = pd.array(\n [True, True, False, False, True, None, True, None, False], dtype=\"boolean\"\n )\n- result = pd.core.algorithms.diff(a, 1)\n+ result = pd._core.algorithms.diff(a, 1)\n expected = pd.array(\n [None, False, True, False, True, None, None, None, None], dtype=\"boolean\"\n )\ndiff --git a/pandas/tests/arrays/boolean/test_logical.py b/pandas/tests/arrays/boolean/test_logical.py\nindex 66c117ea3fc66..5a712388f503b 100644\n--- a/pandas/tests/arrays/boolean/test_logical.py\n+++ b/pandas/tests/arrays/boolean/test_logical.py\n@@ -4,13 +4,13 @@\n import pytest\n \n import pandas as pd\n-import pandas._testing as tm\n-from pandas.arrays import BooleanArray\n-from pandas.core.ops.mask_ops import (\n+from pandas._core.ops.mask_ops import (\n kleene_and,\n kleene_or,\n kleene_xor,\n )\n+import pandas._testing as tm\n+from pandas.arrays import BooleanArray\n from pandas.tests.extension.base import BaseOpsUtil\n \n \ndiff --git a/pandas/tests/arrays/categorical/test_api.py b/pandas/tests/arrays/categorical/test_api.py\nindex 87b1bb88aeac3..8be560f158beb 100644\n--- a/pandas/tests/arrays/categorical/test_api.py\n+++ b/pandas/tests/arrays/categorical/test_api.py\n@@ -10,8 +10,8 @@\n Index,\n Series,\n )\n+from pandas._core.arrays.categorical import recode_for_categories\n import pandas._testing as tm\n-from pandas.core.arrays.categorical import recode_for_categories\n \n \n class TestCategoricalAPI:\ndiff --git a/pandas/tests/arrays/categorical/test_constructors.py b/pandas/tests/arrays/categorical/test_constructors.py\nindex 24f4dd4a1f64a..2b4beb7e43cb2 100644\n--- a/pandas/tests/arrays/categorical/test_constructors.py\n+++ b/pandas/tests/arrays/categorical/test_constructors.py\n@@ -11,11 +11,11 @@\n is_platform_windows,\n )\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_float_dtype,\n is_integer_dtype,\n )\n-from pandas.core.dtypes.dtypes import CategoricalDtype\n+from pandas._core.dtypes.dtypes import CategoricalDtype\n \n import pandas as pd\n from pandas import (\n@@ -33,8 +33,8 @@\n period_range,\n timedelta_range,\n )\n+from pandas._core.api import Int64Index\n import pandas._testing as tm\n-from pandas.core.api import Int64Index\n \n \n class TestCategoricalConstructors:\ndiff --git a/pandas/tests/arrays/categorical/test_dtypes.py b/pandas/tests/arrays/categorical/test_dtypes.py\nindex 5acb62c5ace49..ca811ec6c0a1d 100644\n--- a/pandas/tests/arrays/categorical/test_dtypes.py\n+++ b/pandas/tests/arrays/categorical/test_dtypes.py\n@@ -1,6 +1,6 @@\n import pytest\n \n-from pandas.core.dtypes.dtypes import CategoricalDtype\n+from pandas._core.dtypes.dtypes import CategoricalDtype\n \n from pandas import (\n Categorical,\ndiff --git a/pandas/tests/arrays/categorical/test_indexing.py b/pandas/tests/arrays/categorical/test_indexing.py\nindex 73ac51c258a94..22723a8c25f2b 100644\n--- a/pandas/tests/arrays/categorical/test_indexing.py\n+++ b/pandas/tests/arrays/categorical/test_indexing.py\n@@ -12,8 +12,8 @@\n Timedelta,\n Timestamp,\n )\n+import pandas._core.common as com\n import pandas._testing as tm\n-import pandas.core.common as com\n \n \n class TestCategoricalIndexingWithFactor:\ndiff --git a/pandas/tests/arrays/categorical/test_missing.py b/pandas/tests/arrays/categorical/test_missing.py\nindex fb5330a9665ff..d4c4af539fd36 100644\n--- a/pandas/tests/arrays/categorical/test_missing.py\n+++ b/pandas/tests/arrays/categorical/test_missing.py\n@@ -3,7 +3,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.dtypes import CategoricalDtype\n+from pandas._core.dtypes.dtypes import CategoricalDtype\n \n import pandas as pd\n from pandas import (\ndiff --git a/pandas/tests/arrays/datetimes/test_constructors.py b/pandas/tests/arrays/datetimes/test_constructors.py\nindex 684b478d1de08..068587c30ed34 100644\n--- a/pandas/tests/arrays/datetimes/test_constructors.py\n+++ b/pandas/tests/arrays/datetimes/test_constructors.py\n@@ -1,12 +1,12 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.dtypes import DatetimeTZDtype\n+from pandas._core.dtypes.dtypes import DatetimeTZDtype\n \n import pandas as pd\n+from pandas._core.arrays import DatetimeArray\n+from pandas._core.arrays.datetimes import _sequence_to_dt64ns\n import pandas._testing as tm\n-from pandas.core.arrays import DatetimeArray\n-from pandas.core.arrays.datetimes import _sequence_to_dt64ns\n \n \n class TestDatetimeArrayConstructor:\ndiff --git a/pandas/tests/arrays/datetimes/test_reductions.py b/pandas/tests/arrays/datetimes/test_reductions.py\nindex d0553f9608f25..0d61bcbaed189 100644\n--- a/pandas/tests/arrays/datetimes/test_reductions.py\n+++ b/pandas/tests/arrays/datetimes/test_reductions.py\n@@ -1,12 +1,12 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.dtypes import DatetimeTZDtype\n+from pandas._core.dtypes.dtypes import DatetimeTZDtype\n \n import pandas as pd\n from pandas import NaT\n+from pandas._core.arrays import DatetimeArray\n import pandas._testing as tm\n-from pandas.core.arrays import DatetimeArray\n \n \n class TestReductions:\ndiff --git a/pandas/tests/arrays/floating/conftest.py b/pandas/tests/arrays/floating/conftest.py\nindex 5e971c66029d5..142e4cf2c4973 100644\n--- a/pandas/tests/arrays/floating/conftest.py\n+++ b/pandas/tests/arrays/floating/conftest.py\n@@ -2,7 +2,7 @@\n import pytest\n \n import pandas as pd\n-from pandas.core.arrays.floating import (\n+from pandas._core.arrays.floating import (\n Float32Dtype,\n Float64Dtype,\n )\ndiff --git a/pandas/tests/arrays/floating/test_arithmetic.py b/pandas/tests/arrays/floating/test_arithmetic.py\nindex ec7419d6346a8..2f8aec7024302 100644\n--- a/pandas/tests/arrays/floating/test_arithmetic.py\n+++ b/pandas/tests/arrays/floating/test_arithmetic.py\n@@ -4,8 +4,8 @@\n import pytest\n \n import pandas as pd\n+from pandas._core.arrays import FloatingArray\n import pandas._testing as tm\n-from pandas.core.arrays import FloatingArray\n \n # Basic test for the arithmetic array ops\n # -----------------------------------------------------------------------------\ndiff --git a/pandas/tests/arrays/floating/test_comparison.py b/pandas/tests/arrays/floating/test_comparison.py\nindex a429649f1ce1d..913b5954afb93 100644\n--- a/pandas/tests/arrays/floating/test_comparison.py\n+++ b/pandas/tests/arrays/floating/test_comparison.py\n@@ -2,8 +2,8 @@\n import pytest\n \n import pandas as pd\n+from pandas._core.arrays import FloatingArray\n import pandas._testing as tm\n-from pandas.core.arrays import FloatingArray\n from pandas.tests.arrays.masked_shared import (\n ComparisonOps,\n NumericOps,\ndiff --git a/pandas/tests/arrays/floating/test_construction.py b/pandas/tests/arrays/floating/test_construction.py\nindex ebce80cba237d..66b21225eaf0b 100644\n--- a/pandas/tests/arrays/floating/test_construction.py\n+++ b/pandas/tests/arrays/floating/test_construction.py\n@@ -4,12 +4,12 @@\n from pandas.compat import np_version_under1p20\n \n import pandas as pd\n-import pandas._testing as tm\n-from pandas.core.arrays import FloatingArray\n-from pandas.core.arrays.floating import (\n+from pandas._core.arrays import FloatingArray\n+from pandas._core.arrays.floating import (\n Float32Dtype,\n Float64Dtype,\n )\n+import pandas._testing as tm\n \n \n def test_uses_pandas_na():\ndiff --git a/pandas/tests/arrays/floating/test_repr.py b/pandas/tests/arrays/floating/test_repr.py\nindex a8868fd93747a..0e3998514daac 100644\n--- a/pandas/tests/arrays/floating/test_repr.py\n+++ b/pandas/tests/arrays/floating/test_repr.py\n@@ -2,7 +2,7 @@\n import pytest\n \n import pandas as pd\n-from pandas.core.arrays.floating import (\n+from pandas._core.arrays.floating import (\n Float32Dtype,\n Float64Dtype,\n )\ndiff --git a/pandas/tests/arrays/floating/test_to_numpy.py b/pandas/tests/arrays/floating/test_to_numpy.py\nindex 2ed52439adf53..ba31e8b54cd47 100644\n--- a/pandas/tests/arrays/floating/test_to_numpy.py\n+++ b/pandas/tests/arrays/floating/test_to_numpy.py\n@@ -2,8 +2,8 @@\n import pytest\n \n import pandas as pd\n+from pandas._core.arrays import FloatingArray\n import pandas._testing as tm\n-from pandas.core.arrays import FloatingArray\n \n \n @pytest.mark.parametrize(\"box\", [True, False], ids=[\"series\", \"array\"])\ndiff --git a/pandas/tests/arrays/integer/conftest.py b/pandas/tests/arrays/integer/conftest.py\nindex f73400dfe689e..05299a392444f 100644\n--- a/pandas/tests/arrays/integer/conftest.py\n+++ b/pandas/tests/arrays/integer/conftest.py\n@@ -2,7 +2,7 @@\n import pytest\n \n import pandas as pd\n-from pandas.core.arrays.integer import (\n+from pandas._core.arrays.integer import (\n Int8Dtype,\n Int16Dtype,\n Int32Dtype,\ndiff --git a/pandas/tests/arrays/integer/test_arithmetic.py b/pandas/tests/arrays/integer/test_arithmetic.py\nindex e6a085ceb4d29..daa7b249c3032 100644\n--- a/pandas/tests/arrays/integer/test_arithmetic.py\n+++ b/pandas/tests/arrays/integer/test_arithmetic.py\n@@ -4,9 +4,9 @@\n import pytest\n \n import pandas as pd\n+from pandas._core.arrays import FloatingArray\n+import pandas._core.ops as ops\n import pandas._testing as tm\n-from pandas.core.arrays import FloatingArray\n-import pandas.core.ops as ops\n \n # Basic test for the arithmetic array ops\n # -----------------------------------------------------------------------------\ndiff --git a/pandas/tests/arrays/integer/test_construction.py b/pandas/tests/arrays/integer/test_construction.py\nindex 43ef46ddfb581..5b7b52451b862 100644\n--- a/pandas/tests/arrays/integer/test_construction.py\n+++ b/pandas/tests/arrays/integer/test_construction.py\n@@ -2,14 +2,14 @@\n import pytest\n \n import pandas as pd\n-import pandas._testing as tm\n-from pandas.api.types import is_integer\n-from pandas.core.arrays import IntegerArray\n-from pandas.core.arrays.integer import (\n+from pandas._core.arrays import IntegerArray\n+from pandas._core.arrays.integer import (\n Int8Dtype,\n Int32Dtype,\n Int64Dtype,\n )\n+import pandas._testing as tm\n+from pandas.api.types import is_integer\n \n \n @pytest.fixture(params=[pd.array, IntegerArray._from_sequence])\ndiff --git a/pandas/tests/arrays/integer/test_dtypes.py b/pandas/tests/arrays/integer/test_dtypes.py\nindex 1566476c32989..019428752f02e 100644\n--- a/pandas/tests/arrays/integer/test_dtypes.py\n+++ b/pandas/tests/arrays/integer/test_dtypes.py\n@@ -1,14 +1,14 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.generic import ABCIndex\n+from pandas._core.dtypes.generic import ABCIndex\n \n import pandas as pd\n-import pandas._testing as tm\n-from pandas.core.arrays.integer import (\n+from pandas._core.arrays.integer import (\n Int8Dtype,\n UInt32Dtype,\n )\n+import pandas._testing as tm\n \n \n def test_dtypes(dtype):\ndiff --git a/pandas/tests/arrays/integer/test_function.py b/pandas/tests/arrays/integer/test_function.py\nindex 73c8d4e6b1aed..aca947d0cee59 100644\n--- a/pandas/tests/arrays/integer/test_function.py\n+++ b/pandas/tests/arrays/integer/test_function.py\n@@ -2,8 +2,8 @@\n import pytest\n \n import pandas as pd\n+from pandas._core.arrays import FloatingArray\n import pandas._testing as tm\n-from pandas.core.arrays import FloatingArray\n \n \n @pytest.mark.parametrize(\"ufunc\", [np.abs, np.sign])\ndiff --git a/pandas/tests/arrays/integer/test_repr.py b/pandas/tests/arrays/integer/test_repr.py\nindex 35d07bda9a333..3cf3b4f9f7fc6 100644\n--- a/pandas/tests/arrays/integer/test_repr.py\n+++ b/pandas/tests/arrays/integer/test_repr.py\n@@ -2,7 +2,7 @@\n import pytest\n \n import pandas as pd\n-from pandas.core.arrays.integer import (\n+from pandas._core.arrays.integer import (\n Int8Dtype,\n Int16Dtype,\n Int32Dtype,\ndiff --git a/pandas/tests/arrays/interval/test_interval.py b/pandas/tests/arrays/interval/test_interval.py\nindex 44eafc72b1f5f..a5e876cca93c5 100644\n--- a/pandas/tests/arrays/interval/test_interval.py\n+++ b/pandas/tests/arrays/interval/test_interval.py\n@@ -13,8 +13,8 @@\n date_range,\n timedelta_range,\n )\n+from pandas._core.arrays import IntervalArray\n import pandas._testing as tm\n-from pandas.core.arrays import IntervalArray\n \n \n @pytest.fixture(\n@@ -248,7 +248,7 @@ def test_min_max(self, left_right_dtypes, index_or_series_or_array):\n def test_arrow_extension_type():\n import pyarrow as pa\n \n- from pandas.core.arrays.arrow._arrow_utils import ArrowIntervalType\n+ from pandas._core.arrays.arrow._arrow_utils import ArrowIntervalType\n \n p1 = ArrowIntervalType(pa.int64(), \"left\")\n p2 = ArrowIntervalType(pa.int64(), \"left\")\n@@ -265,7 +265,7 @@ def test_arrow_extension_type():\n def test_arrow_array():\n import pyarrow as pa\n \n- from pandas.core.arrays.arrow._arrow_utils import ArrowIntervalType\n+ from pandas._core.arrays.arrow._arrow_utils import ArrowIntervalType\n \n intervals = pd.interval_range(1, 5, freq=1).array\n \n@@ -295,7 +295,7 @@ def test_arrow_array():\n def test_arrow_array_missing():\n import pyarrow as pa\n \n- from pandas.core.arrays.arrow._arrow_utils import ArrowIntervalType\n+ from pandas._core.arrays.arrow._arrow_utils import ArrowIntervalType\n \n arr = IntervalArray.from_breaks([0.0, 1.0, 2.0, 3.0])\n arr[1] = None\n@@ -330,7 +330,7 @@ def test_arrow_array_missing():\n def test_arrow_table_roundtrip(breaks):\n import pyarrow as pa\n \n- from pandas.core.arrays.arrow._arrow_utils import ArrowIntervalType\n+ from pandas._core.arrays.arrow._arrow_utils import ArrowIntervalType\n \n arr = IntervalArray.from_breaks(breaks)\n arr[1] = None\n@@ -431,7 +431,7 @@ def test_arrow_interval_type_error_and_warning():\n # GH 40245\n import pyarrow as pa\n \n- from pandas.core.arrays.arrow._arrow_utils import ArrowIntervalType\n+ from pandas._core.arrays.arrow._arrow_utils import ArrowIntervalType\n \n msg = (\n \"Deprecated argument `closed` cannot \"\ndiff --git a/pandas/tests/arrays/interval/test_ops.py b/pandas/tests/arrays/interval/test_ops.py\nindex 4853bec51106c..9633fa1e093f1 100644\n--- a/pandas/tests/arrays/interval/test_ops.py\n+++ b/pandas/tests/arrays/interval/test_ops.py\n@@ -8,8 +8,8 @@\n Timedelta,\n Timestamp,\n )\n+from pandas._core.arrays import IntervalArray\n import pandas._testing as tm\n-from pandas.core.arrays import IntervalArray\n \n \n @pytest.fixture(params=[IntervalArray, IntervalIndex])\ndiff --git a/pandas/tests/arrays/masked/test_arrow_compat.py b/pandas/tests/arrays/masked/test_arrow_compat.py\nindex 6b0081321ef22..a024dbbab632e 100644\n--- a/pandas/tests/arrays/masked/test_arrow_compat.py\n+++ b/pandas/tests/arrays/masked/test_arrow_compat.py\n@@ -6,7 +6,7 @@\n \n pa = pytest.importorskip(\"pyarrow\", minversion=\"1.0.1\")\n \n-from pandas.core.arrays.arrow._arrow_utils import pyarrow_array_to_numpy_and_mask\n+from pandas._core.arrays.arrow._arrow_utils import pyarrow_array_to_numpy_and_mask\n \n arrays = [pd.array([1, 2, 3, None], dtype=dtype) for dtype in tm.ALL_INT_EA_DTYPES]\n arrays += [pd.array([0.1, 0.2, 0.3, None], dtype=dtype) for dtype in tm.FLOAT_EA_DTYPES]\ndiff --git a/pandas/tests/arrays/masked/test_function.py b/pandas/tests/arrays/masked/test_function.py\nindex 9a86ef835e5ef..0a4e34bbad097 100644\n--- a/pandas/tests/arrays/masked/test_function.py\n+++ b/pandas/tests/arrays/masked/test_function.py\n@@ -1,7 +1,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import is_integer_dtype\n+from pandas._core.dtypes.common import is_integer_dtype\n \n import pandas as pd\n import pandas._testing as tm\ndiff --git a/pandas/tests/arrays/numpy_/test_indexing.py b/pandas/tests/arrays/numpy_/test_indexing.py\nindex f92411efe774c..71d39c70a28d7 100644\n--- a/pandas/tests/arrays/numpy_/test_indexing.py\n+++ b/pandas/tests/arrays/numpy_/test_indexing.py\n@@ -1,6 +1,6 @@\n import numpy as np\n \n-from pandas.core.dtypes.common import is_scalar\n+from pandas._core.dtypes.common import is_scalar\n \n import pandas as pd\n import pandas._testing as tm\ndiff --git a/pandas/tests/arrays/numpy_/test_numpy.py b/pandas/tests/arrays/numpy_/test_numpy.py\nindex c748d487a2f9c..c6b89abf692bd 100644\n--- a/pandas/tests/arrays/numpy_/test_numpy.py\n+++ b/pandas/tests/arrays/numpy_/test_numpy.py\n@@ -5,7 +5,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.dtypes import PandasDtype\n+from pandas._core.dtypes.dtypes import PandasDtype\n \n import pandas as pd\n import pandas._testing as tm\ndiff --git a/pandas/tests/arrays/period/test_arrow_compat.py b/pandas/tests/arrays/period/test_arrow_compat.py\nindex 7d2d2daed3497..8c0f7eef80ec7 100644\n--- a/pandas/tests/arrays/period/test_arrow_compat.py\n+++ b/pandas/tests/arrays/period/test_arrow_compat.py\n@@ -1,19 +1,19 @@\n import pytest\n \n-from pandas.core.dtypes.dtypes import PeriodDtype\n+from pandas._core.dtypes.dtypes import PeriodDtype\n \n import pandas as pd\n-import pandas._testing as tm\n-from pandas.core.arrays import (\n+from pandas._core.arrays import (\n PeriodArray,\n period_array,\n )\n+import pandas._testing as tm\n \n pa = pytest.importorskip(\"pyarrow\", minversion=\"1.0.1\")\n \n \n def test_arrow_extension_type():\n- from pandas.core.arrays.arrow._arrow_utils import ArrowPeriodType\n+ from pandas._core.arrays.arrow._arrow_utils import ArrowPeriodType\n \n p1 = ArrowPeriodType(\"D\")\n p2 = ArrowPeriodType(\"D\")\n@@ -34,7 +34,7 @@ def test_arrow_extension_type():\n ],\n )\n def test_arrow_array(data, freq):\n- from pandas.core.arrays.arrow._arrow_utils import ArrowPeriodType\n+ from pandas._core.arrays.arrow._arrow_utils import ArrowPeriodType\n \n periods = period_array(data, freq=freq)\n result = pa.array(periods)\n@@ -57,7 +57,7 @@ def test_arrow_array(data, freq):\n \n \n def test_arrow_array_missing():\n- from pandas.core.arrays.arrow._arrow_utils import ArrowPeriodType\n+ from pandas._core.arrays.arrow._arrow_utils import ArrowPeriodType\n \n arr = PeriodArray([1, 2, 3], freq=\"D\")\n arr[1] = pd.NaT\n@@ -70,7 +70,7 @@ def test_arrow_array_missing():\n \n \n def test_arrow_table_roundtrip():\n- from pandas.core.arrays.arrow._arrow_utils import ArrowPeriodType\n+ from pandas._core.arrays.arrow._arrow_utils import ArrowPeriodType\n \n arr = PeriodArray([1, 2, 3], freq=\"D\")\n arr[1] = pd.NaT\n@@ -91,7 +91,7 @@ def test_arrow_table_roundtrip():\n def test_arrow_load_from_zero_chunks():\n # GH-41040\n \n- from pandas.core.arrays.arrow._arrow_utils import ArrowPeriodType\n+ from pandas._core.arrays.arrow._arrow_utils import ArrowPeriodType\n \n arr = PeriodArray([], freq=\"D\")\n df = pd.DataFrame({\"a\": arr})\ndiff --git a/pandas/tests/arrays/period/test_astype.py b/pandas/tests/arrays/period/test_astype.py\nindex e9245c9ca786b..f2d7aea02965b 100644\n--- a/pandas/tests/arrays/period/test_astype.py\n+++ b/pandas/tests/arrays/period/test_astype.py\n@@ -1,11 +1,11 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.dtypes import PeriodDtype\n+from pandas._core.dtypes.dtypes import PeriodDtype\n \n import pandas as pd\n+from pandas._core.arrays import period_array\n import pandas._testing as tm\n-from pandas.core.arrays import period_array\n \n \n @pytest.mark.parametrize(\"dtype\", [int, np.int32, np.int64, \"uint32\", \"uint64\"])\ndiff --git a/pandas/tests/arrays/period/test_constructors.py b/pandas/tests/arrays/period/test_constructors.py\nindex cf9749058d1d1..4ccd2738a512b 100644\n--- a/pandas/tests/arrays/period/test_constructors.py\n+++ b/pandas/tests/arrays/period/test_constructors.py\n@@ -5,11 +5,11 @@\n from pandas._libs.tslibs.period import IncompatibleFrequency\n \n import pandas as pd\n-import pandas._testing as tm\n-from pandas.core.arrays import (\n+from pandas._core.arrays import (\n PeriodArray,\n period_array,\n )\n+import pandas._testing as tm\n \n \n @pytest.mark.parametrize(\ndiff --git a/pandas/tests/arrays/period/test_reductions.py b/pandas/tests/arrays/period/test_reductions.py\nindex 2889cc786dd71..e78dab5162e02 100644\n--- a/pandas/tests/arrays/period/test_reductions.py\n+++ b/pandas/tests/arrays/period/test_reductions.py\n@@ -1,7 +1,7 @@\n import pytest\n \n import pandas as pd\n-from pandas.core.arrays import period_array\n+from pandas._core.arrays import period_array\n \n \n class TestReductions:\ndiff --git a/pandas/tests/arrays/sparse/test_accessor.py b/pandas/tests/arrays/sparse/test_accessor.py\nindex 36af5d32ae461..03483a2efc392 100644\n--- a/pandas/tests/arrays/sparse/test_accessor.py\n+++ b/pandas/tests/arrays/sparse/test_accessor.py\n@@ -6,11 +6,11 @@\n import pandas.util._test_decorators as td\n \n import pandas as pd\n-import pandas._testing as tm\n-from pandas.core.arrays.sparse import (\n+from pandas._core.arrays.sparse import (\n SparseArray,\n SparseDtype,\n )\n+import pandas._testing as tm\n \n \n class TestSeriesAccessor:\n@@ -233,4 +233,6 @@ def test_series_from_coo_incorrect_format_raises(self):\n def test_with_column_named_sparse(self):\n # https://github.com/pandas-dev/pandas/issues/30758\n df = pd.DataFrame({\"sparse\": pd.arrays.SparseArray([1, 2])})\n- assert isinstance(df.sparse, pd.core.arrays.sparse.accessor.SparseFrameAccessor)\n+ assert isinstance(\n+ df.sparse, pd._core.arrays.sparse.accessor.SparseFrameAccessor\n+ )\ndiff --git a/pandas/tests/arrays/sparse/test_arithmetics.py b/pandas/tests/arrays/sparse/test_arithmetics.py\nindex 9593152735ed6..2cf6aaa476a69 100644\n--- a/pandas/tests/arrays/sparse/test_arithmetics.py\n+++ b/pandas/tests/arrays/sparse/test_arithmetics.py\n@@ -6,12 +6,12 @@\n from pandas.compat import np_version_under1p20\n \n import pandas as pd\n-import pandas._testing as tm\n-from pandas.core import ops\n-from pandas.core.arrays.sparse import (\n+from pandas._core import ops\n+from pandas._core.arrays.sparse import (\n SparseArray,\n SparseDtype,\n )\n+import pandas._testing as tm\n \n \n @pytest.fixture(params=[\"integer\", \"block\"])\n@@ -418,7 +418,9 @@ def test_xor(self):\n s = SparseArray([True, True, False, False])\n t = SparseArray([True, False, True, False])\n result = s ^ t\n- sp_index = pd.core.arrays.sparse.IntIndex(4, np.array([0, 1, 2], dtype=\"int32\"))\n+ sp_index = pd._core.arrays.sparse.IntIndex(\n+ 4, np.array([0, 1, 2], dtype=\"int32\")\n+ )\n expected = SparseArray([False, True, True], sparse_index=sp_index)\n tm.assert_sp_array_equal(result, expected)\n \ndiff --git a/pandas/tests/arrays/sparse/test_array.py b/pandas/tests/arrays/sparse/test_array.py\nindex 492427b2be213..0c1070a436cc7 100644\n--- a/pandas/tests/arrays/sparse/test_array.py\n+++ b/pandas/tests/arrays/sparse/test_array.py\n@@ -8,12 +8,12 @@\n \n import pandas as pd\n from pandas import isna\n-import pandas._testing as tm\n-from pandas.core.api import Int64Index\n-from pandas.core.arrays.sparse import (\n+from pandas._core.api import Int64Index\n+from pandas._core.arrays.sparse import (\n SparseArray,\n SparseDtype,\n )\n+import pandas._testing as tm\n \n \n @pytest.fixture\ndiff --git a/pandas/tests/arrays/sparse/test_astype.py b/pandas/tests/arrays/sparse/test_astype.py\nindex 6761040d444a5..c2c48bf9e5157 100644\n--- a/pandas/tests/arrays/sparse/test_astype.py\n+++ b/pandas/tests/arrays/sparse/test_astype.py\n@@ -4,11 +4,11 @@\n from pandas._libs.sparse import IntIndex\n \n from pandas import Timestamp\n-import pandas._testing as tm\n-from pandas.core.arrays.sparse import (\n+from pandas._core.arrays.sparse import (\n SparseArray,\n SparseDtype,\n )\n+import pandas._testing as tm\n \n \n class TestAstype:\ndiff --git a/pandas/tests/arrays/sparse/test_combine_concat.py b/pandas/tests/arrays/sparse/test_combine_concat.py\nindex 0f09af269148b..60e77f0d52a1d 100644\n--- a/pandas/tests/arrays/sparse/test_combine_concat.py\n+++ b/pandas/tests/arrays/sparse/test_combine_concat.py\n@@ -2,8 +2,8 @@\n import pytest\n \n import pandas as pd\n+from pandas._core.arrays.sparse import SparseArray\n import pandas._testing as tm\n-from pandas.core.arrays.sparse import SparseArray\n \n \n class TestSparseArrayConcat:\ndiff --git a/pandas/tests/arrays/sparse/test_constructors.py b/pandas/tests/arrays/sparse/test_constructors.py\nindex e1d401f198533..7cba8b4e05c58 100644\n--- a/pandas/tests/arrays/sparse/test_constructors.py\n+++ b/pandas/tests/arrays/sparse/test_constructors.py\n@@ -6,11 +6,11 @@\n \n import pandas as pd\n from pandas import isna\n-import pandas._testing as tm\n-from pandas.core.arrays.sparse import (\n+from pandas._core.arrays.sparse import (\n SparseArray,\n SparseDtype,\n )\n+import pandas._testing as tm\n \n \n class TestConstructors:\ndiff --git a/pandas/tests/arrays/sparse/test_dtype.py b/pandas/tests/arrays/sparse/test_dtype.py\nindex 58fedbd3e4231..4294e9ff58b46 100644\n--- a/pandas/tests/arrays/sparse/test_dtype.py\n+++ b/pandas/tests/arrays/sparse/test_dtype.py\n@@ -4,7 +4,7 @@\n import pytest\n \n import pandas as pd\n-from pandas.core.arrays.sparse import SparseDtype\n+from pandas._core.arrays.sparse import SparseDtype\n \n \n @pytest.mark.parametrize(\ndiff --git a/pandas/tests/arrays/sparse/test_indexing.py b/pandas/tests/arrays/sparse/test_indexing.py\nindex 7ea36ed041f44..d46770baf45f4 100644\n--- a/pandas/tests/arrays/sparse/test_indexing.py\n+++ b/pandas/tests/arrays/sparse/test_indexing.py\n@@ -2,11 +2,11 @@\n import pytest\n \n import pandas as pd\n-import pandas._testing as tm\n-from pandas.core.arrays.sparse import (\n+from pandas._core.arrays.sparse import (\n SparseArray,\n SparseDtype,\n )\n+import pandas._testing as tm\n \n arr_data = np.array([np.nan, np.nan, 1, 2, 3, np.nan, 4, 5, np.nan, 6])\n arr = SparseArray(arr_data)\ndiff --git a/pandas/tests/arrays/sparse/test_libsparse.py b/pandas/tests/arrays/sparse/test_libsparse.py\nindex 35d58c29b1e03..af83b79c496fa 100644\n--- a/pandas/tests/arrays/sparse/test_libsparse.py\n+++ b/pandas/tests/arrays/sparse/test_libsparse.py\n@@ -7,12 +7,12 @@\n import pandas.util._test_decorators as td\n \n from pandas import Series\n-import pandas._testing as tm\n-from pandas.core.arrays.sparse import (\n+from pandas._core.arrays.sparse import (\n BlockIndex,\n IntIndex,\n make_sparse_index,\n )\n+import pandas._testing as tm\n \n TEST_LENGTH = 20\n \ndiff --git a/pandas/tests/arrays/sparse/test_reductions.py b/pandas/tests/arrays/sparse/test_reductions.py\nindex a33a282bb4869..10cab584de7ed 100644\n--- a/pandas/tests/arrays/sparse/test_reductions.py\n+++ b/pandas/tests/arrays/sparse/test_reductions.py\n@@ -6,7 +6,7 @@\n Timestamp,\n isna,\n )\n-from pandas.core.arrays.sparse import (\n+from pandas._core.arrays.sparse import (\n SparseArray,\n SparseDtype,\n )\ndiff --git a/pandas/tests/arrays/sparse/test_unary.py b/pandas/tests/arrays/sparse/test_unary.py\nindex a34c3b0787753..b236f5ea5f726 100644\n--- a/pandas/tests/arrays/sparse/test_unary.py\n+++ b/pandas/tests/arrays/sparse/test_unary.py\n@@ -4,8 +4,8 @@\n import pytest\n \n import pandas as pd\n+from pandas._core.arrays import SparseArray\n import pandas._testing as tm\n-from pandas.core.arrays import SparseArray\n \n \n @pytest.mark.parametrize(\"fill_value\", [0, np.nan])\ndiff --git a/pandas/tests/arrays/string_/test_indexing.py b/pandas/tests/arrays/string_/test_indexing.py\nindex 41466c43288c3..69b05d3c5b4cc 100644\n--- a/pandas/tests/arrays/string_/test_indexing.py\n+++ b/pandas/tests/arrays/string_/test_indexing.py\n@@ -1,4 +1,4 @@\n-from pandas.core.dtypes.common import is_scalar\n+from pandas._core.dtypes.common import is_scalar\n \n import pandas as pd\n \ndiff --git a/pandas/tests/arrays/string_/test_string.py b/pandas/tests/arrays/string_/test_string.py\nindex b563f84207b22..0a20a8022fa50 100644\n--- a/pandas/tests/arrays/string_/test_string.py\n+++ b/pandas/tests/arrays/string_/test_string.py\n@@ -9,11 +9,11 @@\n from pandas.errors import PerformanceWarning\n import pandas.util._test_decorators as td\n \n-from pandas.core.dtypes.common import is_dtype_equal\n+from pandas._core.dtypes.common import is_dtype_equal\n \n import pandas as pd\n+from pandas._core.arrays.string_arrow import ArrowStringArray\n import pandas._testing as tm\n-from pandas.core.arrays.string_arrow import ArrowStringArray\n \n \n @pytest.fixture\ndiff --git a/pandas/tests/arrays/string_/test_string_arrow.py b/pandas/tests/arrays/string_/test_string_arrow.py\nindex f43cf298857a0..edc8661a9bcbd 100644\n--- a/pandas/tests/arrays/string_/test_string_arrow.py\n+++ b/pandas/tests/arrays/string_/test_string_arrow.py\n@@ -6,12 +6,12 @@\n from pandas.compat import pa_version_under1p01\n \n import pandas as pd\n-import pandas._testing as tm\n-from pandas.core.arrays.string_ import (\n+from pandas._core.arrays.string_ import (\n StringArray,\n StringDtype,\n )\n-from pandas.core.arrays.string_arrow import ArrowStringArray\n+from pandas._core.arrays.string_arrow import ArrowStringArray\n+import pandas._testing as tm\n \n skip_if_no_pyarrow = pytest.mark.skipif(\n pa_version_under1p01,\ndiff --git a/pandas/tests/arrays/test_array.py b/pandas/tests/arrays/test_array.py\nindex f7f015cbe4a23..713c3b4552247 100644\n--- a/pandas/tests/arrays/test_array.py\n+++ b/pandas/tests/arrays/test_array.py\n@@ -5,9 +5,13 @@\n import pytest\n import pytz\n \n-from pandas.core.dtypes.base import _registry as registry\n+from pandas._core.dtypes.base import _registry as registry\n \n import pandas as pd\n+from pandas._core.arrays import (\n+ PandasArray,\n+ period_array,\n+)\n import pandas._testing as tm\n from pandas.api.extensions import register_extension_dtype\n from pandas.arrays import (\n@@ -19,10 +23,6 @@\n SparseArray,\n TimedeltaArray,\n )\n-from pandas.core.arrays import (\n- PandasArray,\n- period_array,\n-)\n from pandas.tests.extension.decimal import (\n DecimalArray,\n DecimalDtype,\ndiff --git a/pandas/tests/arrays/test_datetimelike.py b/pandas/tests/arrays/test_datetimelike.py\nindex 10881495c27b3..f698b7c872a61 100644\n--- a/pandas/tests/arrays/test_datetimelike.py\n+++ b/pandas/tests/arrays/test_datetimelike.py\n@@ -19,15 +19,15 @@\n PeriodIndex,\n TimedeltaIndex,\n )\n-import pandas._testing as tm\n-from pandas.core.arrays import (\n+from pandas._core.arrays import (\n DatetimeArray,\n PandasArray,\n PeriodArray,\n TimedeltaArray,\n )\n-from pandas.core.arrays.datetimes import _sequence_to_dt64ns\n-from pandas.core.arrays.timedeltas import sequence_to_td64ns\n+from pandas._core.arrays.datetimes import _sequence_to_dt64ns\n+from pandas._core.arrays.timedeltas import sequence_to_td64ns\n+import pandas._testing as tm\n \n \n # TODO: more freq variants\ndiff --git a/pandas/tests/arrays/test_datetimes.py b/pandas/tests/arrays/test_datetimes.py\nindex 6c6a8b269aee8..c25841b73011b 100644\n--- a/pandas/tests/arrays/test_datetimes.py\n+++ b/pandas/tests/arrays/test_datetimes.py\n@@ -7,11 +7,11 @@\n from pandas._libs.tslibs import tz_compare\n from pandas._libs.tslibs.dtypes import NpyDatetimeUnit\n \n-from pandas.core.dtypes.dtypes import DatetimeTZDtype\n+from pandas._core.dtypes.dtypes import DatetimeTZDtype\n \n import pandas as pd\n+from pandas._core.arrays import DatetimeArray\n import pandas._testing as tm\n-from pandas.core.arrays import DatetimeArray\n \n \n class TestNonNano:\ndiff --git a/pandas/tests/arrays/test_ndarray_backed.py b/pandas/tests/arrays/test_ndarray_backed.py\nindex c48fb7e78d45b..3d9df7064849b 100644\n--- a/pandas/tests/arrays/test_ndarray_backed.py\n+++ b/pandas/tests/arrays/test_ndarray_backed.py\n@@ -7,7 +7,7 @@\n CategoricalIndex,\n date_range,\n )\n-from pandas.core.arrays import (\n+from pandas._core.arrays import (\n Categorical,\n DatetimeArray,\n PandasArray,\ndiff --git a/pandas/tests/arrays/test_period.py b/pandas/tests/arrays/test_period.py\nindex de0e766e4a2aa..c4a193de403a2 100644\n--- a/pandas/tests/arrays/test_period.py\n+++ b/pandas/tests/arrays/test_period.py\n@@ -4,15 +4,15 @@\n from pandas._libs.tslibs import iNaT\n from pandas._libs.tslibs.period import IncompatibleFrequency\n \n-from pandas.core.dtypes.base import _registry as registry\n-from pandas.core.dtypes.dtypes import PeriodDtype\n+from pandas._core.dtypes.base import _registry as registry\n+from pandas._core.dtypes.dtypes import PeriodDtype\n \n import pandas as pd\n-import pandas._testing as tm\n-from pandas.core.arrays import (\n+from pandas._core.arrays import (\n PeriodArray,\n period_array,\n )\n+import pandas._testing as tm\n \n # ----------------------------------------------------------------------------\n # Dtype\ndiff --git a/pandas/tests/arrays/test_timedeltas.py b/pandas/tests/arrays/test_timedeltas.py\nindex c8b850d35035a..d45701cafe49e 100644\n--- a/pandas/tests/arrays/test_timedeltas.py\n+++ b/pandas/tests/arrays/test_timedeltas.py\n@@ -5,8 +5,8 @@\n \n import pandas as pd\n from pandas import Timedelta\n+from pandas._core.arrays import TimedeltaArray\n import pandas._testing as tm\n-from pandas.core.arrays import TimedeltaArray\n \n \n class TestNonNano:\ndiff --git a/pandas/tests/arrays/timedeltas/test_constructors.py b/pandas/tests/arrays/timedeltas/test_constructors.py\nindex d24fabfeecb26..c47a4c76ef3f0 100644\n--- a/pandas/tests/arrays/timedeltas/test_constructors.py\n+++ b/pandas/tests/arrays/timedeltas/test_constructors.py\n@@ -1,7 +1,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.arrays import TimedeltaArray\n+from pandas._core.arrays import TimedeltaArray\n \n \n class TestTimedeltaArrayConstructor:\ndiff --git a/pandas/tests/arrays/timedeltas/test_reductions.py b/pandas/tests/arrays/timedeltas/test_reductions.py\nindex 72d45f5b9a78c..c1341df83d41b 100644\n--- a/pandas/tests/arrays/timedeltas/test_reductions.py\n+++ b/pandas/tests/arrays/timedeltas/test_reductions.py\n@@ -3,9 +3,9 @@\n \n import pandas as pd\n from pandas import Timedelta\n+from pandas._core import nanops\n+from pandas._core.arrays import TimedeltaArray\n import pandas._testing as tm\n-from pandas.core import nanops\n-from pandas.core.arrays import TimedeltaArray\n \n \n class TestReductions:\ndiff --git a/pandas/tests/base/test_constructors.py b/pandas/tests/base/test_constructors.py\nindex 44d6bc57b0431..8d1257d8a4a90 100644\n--- a/pandas/tests/base/test_constructors.py\n+++ b/pandas/tests/base/test_constructors.py\n@@ -12,12 +12,12 @@\n Index,\n Series,\n )\n-import pandas._testing as tm\n-from pandas.core.accessor import PandasDelegate\n-from pandas.core.base import (\n+from pandas._core.accessor import PandasDelegate\n+from pandas._core.base import (\n NoNewAttributesMixin,\n PandasObject,\n )\n+import pandas._testing as tm\n \n \n @pytest.fixture(\ndiff --git a/pandas/tests/base/test_conversion.py b/pandas/tests/base/test_conversion.py\nindex 3adaddf89cf30..399a5a6f868ad 100644\n--- a/pandas/tests/base/test_conversion.py\n+++ b/pandas/tests/base/test_conversion.py\n@@ -1,11 +1,11 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_datetime64_dtype,\n is_timedelta64_dtype,\n )\n-from pandas.core.dtypes.dtypes import DatetimeTZDtype\n+from pandas._core.dtypes.dtypes import DatetimeTZDtype\n \n import pandas as pd\n from pandas import (\n@@ -15,8 +15,7 @@\n Timestamp,\n date_range,\n )\n-import pandas._testing as tm\n-from pandas.core.arrays import (\n+from pandas._core.arrays import (\n DatetimeArray,\n IntervalArray,\n PandasArray,\n@@ -24,6 +23,7 @@\n SparseArray,\n TimedeltaArray,\n )\n+import pandas._testing as tm\n \n \n class TestToIterable:\n@@ -190,7 +190,7 @@ def test_iter_box(self):\n (\n pd.PeriodIndex([2018, 2019], freq=\"A\"),\n PeriodArray,\n- pd.core.dtypes.dtypes.PeriodDtype(\"A-DEC\"),\n+ pd._core.dtypes.dtypes.PeriodDtype(\"A-DEC\"),\n ),\n (pd.IntervalIndex.from_breaks([0, 1, 2]), IntervalArray, \"interval\"),\n (\n@@ -237,7 +237,7 @@ def test_numpy_array_all_dtypes(any_numpy_dtype):\n \"arr, attr\",\n [\n (pd.Categorical([\"a\", \"b\"]), \"_codes\"),\n- (pd.core.arrays.period_array([\"2000\", \"2001\"], freq=\"D\"), \"_data\"),\n+ (pd._core.arrays.period_array([\"2000\", \"2001\"], freq=\"D\"), \"_data\"),\n (pd.array([0, np.nan], dtype=\"Int64\"), \"_data\"),\n (IntervalArray.from_breaks([0, 1]), \"_left\"),\n (SparseArray([0, 1]), \"_sparse_values\"),\n@@ -285,7 +285,7 @@ def test_array_multiindex_raises():\n (np.array([1, 2], dtype=np.int64), np.array([1, 2], dtype=np.int64)),\n (pd.Categorical([\"a\", \"b\"]), np.array([\"a\", \"b\"], dtype=object)),\n (\n- pd.core.arrays.period_array([\"2000\", \"2001\"], freq=\"D\"),\n+ pd._core.arrays.period_array([\"2000\", \"2001\"], freq=\"D\"),\n np.array([pd.Period(\"2000\", freq=\"D\"), pd.Period(\"2001\", freq=\"D\")]),\n ),\n (pd.array([0, np.nan], dtype=\"Int64\"), np.array([0, pd.NA], dtype=object)),\ndiff --git a/pandas/tests/base/test_misc.py b/pandas/tests/base/test_misc.py\nindex a55c013a7340d..a79d595a87caa 100644\n--- a/pandas/tests/base/test_misc.py\n+++ b/pandas/tests/base/test_misc.py\n@@ -8,7 +8,7 @@\n PYPY,\n )\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_categorical_dtype,\n is_dtype_equal,\n is_object_dtype,\ndiff --git a/pandas/tests/base/test_unique.py b/pandas/tests/base/test_unique.py\nindex eac1e35699585..7ea91ab4f1ca5 100644\n--- a/pandas/tests/base/test_unique.py\n+++ b/pandas/tests/base/test_unique.py\n@@ -4,11 +4,11 @@\n from pandas.compat import pa_version_under2p0\n from pandas.errors import PerformanceWarning\n \n-from pandas.core.dtypes.common import is_datetime64tz_dtype\n+from pandas._core.dtypes.common import is_datetime64tz_dtype\n \n import pandas as pd\n+from pandas._core.api import NumericIndex\n import pandas._testing as tm\n-from pandas.core.api import NumericIndex\n from pandas.tests.base.common import allow_na_ops\n \n \ndiff --git a/pandas/tests/computation/test_compat.py b/pandas/tests/computation/test_compat.py\nindex cfc08426f84e3..4181ab05e4fcf 100644\n--- a/pandas/tests/computation/test_compat.py\n+++ b/pandas/tests/computation/test_compat.py\n@@ -3,15 +3,15 @@\n from pandas.compat._optional import VERSIONS\n \n import pandas as pd\n-from pandas.core.computation.engines import ENGINES\n-import pandas.core.computation.expr as expr\n+from pandas._core.computation.engines import ENGINES\n+import pandas._core.computation.expr as expr\n from pandas.util.version import Version\n \n \n def test_compat():\n # test we have compat with our version of numexpr\n \n- from pandas.core.computation.check import NUMEXPR_INSTALLED\n+ from pandas._core.computation.check import NUMEXPR_INSTALLED\n \n ne = pytest.importorskip(\"numexpr\")\n \ndiff --git a/pandas/tests/computation/test_eval.py b/pandas/tests/computation/test_eval.py\nindex b0ad2f69a75b9..426470c0a57cd 100644\n--- a/pandas/tests/computation/test_eval.py\n+++ b/pandas/tests/computation/test_eval.py\n@@ -16,7 +16,7 @@\n )\n import pandas.util._test_decorators as td\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_bool,\n is_float,\n is_list_like,\n@@ -29,26 +29,26 @@\n Series,\n date_range,\n )\n-import pandas._testing as tm\n-from pandas.core.computation import pytables\n-from pandas.core.computation.engines import ENGINES\n-import pandas.core.computation.expr as expr\n-from pandas.core.computation.expr import (\n+from pandas._core.computation import pytables\n+from pandas._core.computation.engines import ENGINES\n+import pandas._core.computation.expr as expr\n+from pandas._core.computation.expr import (\n BaseExprVisitor,\n PandasExprVisitor,\n PythonExprVisitor,\n )\n-from pandas.core.computation.expressions import (\n+from pandas._core.computation.expressions import (\n NUMEXPR_INSTALLED,\n USE_NUMEXPR,\n )\n-from pandas.core.computation.ops import (\n+from pandas._core.computation.ops import (\n ARITH_OPS_SYMS,\n SPECIAL_CASE_ARITH_OPS_SYMS,\n _binary_math_ops,\n _binary_ops_dict,\n _unary_math_ops,\n )\n+import pandas._testing as tm\n \n \n @pytest.fixture(\n@@ -1704,7 +1704,7 @@ def test_invalid_engine():\n )\n def test_numexpr_option_respected(use_numexpr, expected):\n # GH 32556\n- from pandas.core.computation.eval import _check_engine\n+ from pandas._core.computation.eval import _check_engine\n \n with pd.option_context(\"compute.use_numexpr\", use_numexpr):\n result = _check_engine(None)\ndiff --git a/pandas/tests/construction/test_extract_array.py b/pandas/tests/construction/test_extract_array.py\nindex 4dd3eda8c995c..8d081593f60dd 100644\n--- a/pandas/tests/construction/test_extract_array.py\n+++ b/pandas/tests/construction/test_extract_array.py\n@@ -1,6 +1,6 @@\n from pandas import Index\n+from pandas._core.construction import extract_array\n import pandas._testing as tm\n-from pandas.core.construction import extract_array\n \n \n def test_extract_array_rangeindex():\ndiff --git a/pandas/tests/dtypes/cast/test_can_hold_element.py b/pandas/tests/dtypes/cast/test_can_hold_element.py\nindex 3b7d76ead119a..4638459e0eede 100644\n--- a/pandas/tests/dtypes/cast/test_can_hold_element.py\n+++ b/pandas/tests/dtypes/cast/test_can_hold_element.py\n@@ -1,6 +1,6 @@\n import numpy as np\n \n-from pandas.core.dtypes.cast import can_hold_element\n+from pandas._core.dtypes.cast import can_hold_element\n \n \n def test_can_hold_element_range(any_int_numpy_dtype):\ndiff --git a/pandas/tests/dtypes/cast/test_construct_from_scalar.py b/pandas/tests/dtypes/cast/test_construct_from_scalar.py\nindex 0ce04ce2e64cd..5197aab8f89c8 100644\n--- a/pandas/tests/dtypes/cast/test_construct_from_scalar.py\n+++ b/pandas/tests/dtypes/cast/test_construct_from_scalar.py\n@@ -1,8 +1,8 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.cast import construct_1d_arraylike_from_scalar\n-from pandas.core.dtypes.dtypes import CategoricalDtype\n+from pandas._core.dtypes.cast import construct_1d_arraylike_from_scalar\n+from pandas._core.dtypes.dtypes import CategoricalDtype\n \n from pandas import (\n Categorical,\ndiff --git a/pandas/tests/dtypes/cast/test_construct_ndarray.py b/pandas/tests/dtypes/cast/test_construct_ndarray.py\nindex 10085ddde5c8f..b3b007dc5bf75 100644\n--- a/pandas/tests/dtypes/cast/test_construct_ndarray.py\n+++ b/pandas/tests/dtypes/cast/test_construct_ndarray.py\n@@ -1,8 +1,8 @@\n import numpy as np\n import pytest\n \n+from pandas._core.construction import sanitize_array\n import pandas._testing as tm\n-from pandas.core.construction import sanitize_array\n \n \n @pytest.mark.parametrize(\ndiff --git a/pandas/tests/dtypes/cast/test_construct_object_arr.py b/pandas/tests/dtypes/cast/test_construct_object_arr.py\nindex cb44f91f34dec..9f479256a3f9e 100644\n--- a/pandas/tests/dtypes/cast/test_construct_object_arr.py\n+++ b/pandas/tests/dtypes/cast/test_construct_object_arr.py\n@@ -1,6 +1,6 @@\n import pytest\n \n-from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike\n+from pandas._core.dtypes.cast import construct_1d_object_array_from_listlike\n \n \n @pytest.mark.parametrize(\"datum1\", [1, 2.0, \"3\", (4, 5), [6, 7], None])\ndiff --git a/pandas/tests/dtypes/cast/test_dict_compat.py b/pandas/tests/dtypes/cast/test_dict_compat.py\nindex 13dc82d779f95..5de7869367e0f 100644\n--- a/pandas/tests/dtypes/cast/test_dict_compat.py\n+++ b/pandas/tests/dtypes/cast/test_dict_compat.py\n@@ -1,6 +1,6 @@\n import numpy as np\n \n-from pandas.core.dtypes.cast import dict_compat\n+from pandas._core.dtypes.cast import dict_compat\n \n from pandas import Timestamp\n \ndiff --git a/pandas/tests/dtypes/cast/test_downcast.py b/pandas/tests/dtypes/cast/test_downcast.py\nindex c01eac746455c..23d3c21375aa4 100644\n--- a/pandas/tests/dtypes/cast/test_downcast.py\n+++ b/pandas/tests/dtypes/cast/test_downcast.py\n@@ -3,7 +3,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.cast import maybe_downcast_to_dtype\n+from pandas._core.dtypes.cast import maybe_downcast_to_dtype\n \n from pandas import (\n Series,\ndiff --git a/pandas/tests/dtypes/cast/test_find_common_type.py b/pandas/tests/dtypes/cast/test_find_common_type.py\nindex 8484b5525a92a..d29b885d0641f 100644\n--- a/pandas/tests/dtypes/cast/test_find_common_type.py\n+++ b/pandas/tests/dtypes/cast/test_find_common_type.py\n@@ -1,8 +1,8 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.cast import find_common_type\n-from pandas.core.dtypes.dtypes import (\n+from pandas._core.dtypes.cast import find_common_type\n+from pandas._core.dtypes.dtypes import (\n CategoricalDtype,\n DatetimeTZDtype,\n IntervalDtype,\ndiff --git a/pandas/tests/dtypes/cast/test_infer_dtype.py b/pandas/tests/dtypes/cast/test_infer_dtype.py\nindex 902130bf93d54..948357729fa59 100644\n--- a/pandas/tests/dtypes/cast/test_infer_dtype.py\n+++ b/pandas/tests/dtypes/cast/test_infer_dtype.py\n@@ -7,12 +7,12 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.cast import (\n+from pandas._core.dtypes.cast import (\n infer_dtype_from,\n infer_dtype_from_array,\n infer_dtype_from_scalar,\n )\n-from pandas.core.dtypes.common import is_dtype_equal\n+from pandas._core.dtypes.common import is_dtype_equal\n \n from pandas import (\n Categorical,\ndiff --git a/pandas/tests/dtypes/cast/test_maybe_box_native.py b/pandas/tests/dtypes/cast/test_maybe_box_native.py\nindex 3f62f31dac219..8f17c8b5cc871 100644\n--- a/pandas/tests/dtypes/cast/test_maybe_box_native.py\n+++ b/pandas/tests/dtypes/cast/test_maybe_box_native.py\n@@ -3,7 +3,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.cast import maybe_box_native\n+from pandas._core.dtypes.cast import maybe_box_native\n \n from pandas import (\n Interval,\ndiff --git a/pandas/tests/dtypes/cast/test_promote.py b/pandas/tests/dtypes/cast/test_promote.py\nindex 02bd03f5ea266..f4245d60237a0 100644\n--- a/pandas/tests/dtypes/cast/test_promote.py\n+++ b/pandas/tests/dtypes/cast/test_promote.py\n@@ -10,8 +10,8 @@\n \n from pandas._libs.tslibs import NaT\n \n-from pandas.core.dtypes.cast import maybe_promote\n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.cast import maybe_promote\n+from pandas._core.dtypes.common import (\n is_complex_dtype,\n is_datetime64_dtype,\n is_datetime_or_timedelta_dtype,\n@@ -21,8 +21,8 @@\n is_scalar,\n is_timedelta64_dtype,\n )\n-from pandas.core.dtypes.dtypes import DatetimeTZDtype\n-from pandas.core.dtypes.missing import isna\n+from pandas._core.dtypes.dtypes import DatetimeTZDtype\n+from pandas._core.dtypes.missing import isna\n \n import pandas as pd\n import pandas._testing as tm\ndiff --git a/pandas/tests/dtypes/test_common.py b/pandas/tests/dtypes/test_common.py\nindex c5d0567b6dfc0..74762b938d668 100644\n--- a/pandas/tests/dtypes/test_common.py\n+++ b/pandas/tests/dtypes/test_common.py\n@@ -7,16 +7,16 @@\n \n import pandas.util._test_decorators as td\n \n-from pandas.core.dtypes.astype import astype_nansafe\n-import pandas.core.dtypes.common as com\n-from pandas.core.dtypes.dtypes import (\n+from pandas._core.dtypes.astype import astype_nansafe\n+import pandas._core.dtypes.common as com\n+from pandas._core.dtypes.dtypes import (\n CategoricalDtype,\n CategoricalDtypeType,\n DatetimeTZDtype,\n IntervalDtype,\n PeriodDtype,\n )\n-from pandas.core.dtypes.missing import isna\n+from pandas._core.dtypes.missing import isna\n \n import pandas as pd\n import pandas._testing as tm\n@@ -157,7 +157,7 @@ def test_dtype_equal_strict(dtype1, dtype2):\n \n def get_is_dtype_funcs():\n \"\"\"\n- Get all functions in pandas.core.dtypes.common that\n+ Get all functions in pandas._core.dtypes.common that\n begin with 'is_' and end with 'dtype'\n \n \"\"\"\ndiff --git a/pandas/tests/dtypes/test_concat.py b/pandas/tests/dtypes/test_concat.py\nindex f624c56b54001..08893f9b98d09 100644\n--- a/pandas/tests/dtypes/test_concat.py\n+++ b/pandas/tests/dtypes/test_concat.py\n@@ -1,6 +1,6 @@\n import pytest\n \n-import pandas.core.dtypes.concat as _concat\n+import pandas._core.dtypes.concat as _concat\n \n import pandas as pd\n from pandas import Series\ndiff --git a/pandas/tests/dtypes/test_dtypes.py b/pandas/tests/dtypes/test_dtypes.py\nindex e127fe27b6209..08f00c2479561 100644\n--- a/pandas/tests/dtypes/test_dtypes.py\n+++ b/pandas/tests/dtypes/test_dtypes.py\n@@ -6,8 +6,8 @@\n \n from pandas._libs.tslibs.dtypes import NpyDatetimeUnit\n \n-from pandas.core.dtypes.base import _registry as registry\n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.base import _registry as registry\n+from pandas._core.dtypes.common import (\n is_bool_dtype,\n is_categorical,\n is_categorical_dtype,\n@@ -20,7 +20,7 @@\n is_period_dtype,\n is_string_dtype,\n )\n-from pandas.core.dtypes.dtypes import (\n+from pandas._core.dtypes.dtypes import (\n CategoricalDtype,\n DatetimeTZDtype,\n IntervalDtype,\n@@ -36,11 +36,11 @@\n Series,\n date_range,\n )\n-import pandas._testing as tm\n-from pandas.core.arrays.sparse import (\n+from pandas._core.arrays.sparse import (\n SparseArray,\n SparseDtype,\n )\n+import pandas._testing as tm\n \n \n class Base:\ndiff --git a/pandas/tests/dtypes/test_generic.py b/pandas/tests/dtypes/test_generic.py\nindex 4f73754d2708f..4e3fcb76c327b 100644\n--- a/pandas/tests/dtypes/test_generic.py\n+++ b/pandas/tests/dtypes/test_generic.py\n@@ -4,15 +4,15 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes import generic as gt\n+from pandas._core.dtypes import generic as gt\n \n import pandas as pd\n-import pandas._testing as tm\n-from pandas.core.api import (\n+from pandas._core.api import (\n Float64Index,\n Int64Index,\n UInt64Index,\n )\n+import pandas._testing as tm\n \n \n class TestABCClasses:\n@@ -25,8 +25,8 @@ class TestABCClasses:\n categorical_df = pd.DataFrame({\"values\": [1, 2, 3]}, index=categorical)\n df = pd.DataFrame({\"names\": [\"a\", \"b\", \"c\"]}, index=multi_index)\n sparse_array = pd.arrays.SparseArray(np.random.randn(10))\n- datetime_array = pd.core.arrays.DatetimeArray(datetime_index)\n- timedelta_array = pd.core.arrays.TimedeltaArray(timedelta_index)\n+ datetime_array = pd._core.arrays.DatetimeArray(datetime_index)\n+ timedelta_array = pd._core.arrays.TimedeltaArray(timedelta_index)\n \n abc_pairs = [\n (\"ABCInt64Index\", Int64Index([1, 2, 3])),\ndiff --git a/pandas/tests/dtypes/test_inference.py b/pandas/tests/dtypes/test_inference.py\nindex b12476deccbfc..30060e0eefe7f 100644\n--- a/pandas/tests/dtypes/test_inference.py\n+++ b/pandas/tests/dtypes/test_inference.py\n@@ -30,8 +30,8 @@\n )\n import pandas.util._test_decorators as td\n \n-from pandas.core.dtypes import inference\n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes import inference\n+from pandas._core.dtypes.common import (\n ensure_int32,\n is_bool,\n is_complex,\n@@ -63,12 +63,12 @@\n TimedeltaIndex,\n Timestamp,\n )\n-import pandas._testing as tm\n-from pandas.core.arrays import (\n+from pandas._core.arrays import (\n BooleanArray,\n FloatingArray,\n IntegerArray,\n )\n+import pandas._testing as tm\n \n \n @pytest.fixture(params=[True, False], ids=str)\ndiff --git a/pandas/tests/dtypes/test_missing.py b/pandas/tests/dtypes/test_missing.py\nindex 9c8aeb050ec27..dfe4f25b0f3ac 100644\n--- a/pandas/tests/dtypes/test_missing.py\n+++ b/pandas/tests/dtypes/test_missing.py\n@@ -10,17 +10,17 @@\n from pandas._libs import missing as libmissing\n from pandas._libs.tslibs import iNaT\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_float,\n is_scalar,\n )\n-from pandas.core.dtypes.dtypes import (\n+from pandas._core.dtypes.dtypes import (\n CategoricalDtype,\n DatetimeTZDtype,\n IntervalDtype,\n PeriodDtype,\n )\n-from pandas.core.dtypes.missing import (\n+from pandas._core.dtypes.missing import (\n array_equivalent,\n is_valid_na_for_dtype,\n isna,\n@@ -38,8 +38,8 @@\n TimedeltaIndex,\n date_range,\n )\n+from pandas._core.api import Float64Index\n import pandas._testing as tm\n-from pandas.core.api import Float64Index\n \n fix_now = pd.Timestamp(\"2021-01-01\")\n fix_utcnow = pd.Timestamp(\"2021-01-01\", tz=\"UTC\")\ndiff --git a/pandas/tests/exchange/test_impl.py b/pandas/tests/exchange/test_impl.py\nindex e0e9fdce645d0..15a82c5e4b5b0 100644\n--- a/pandas/tests/exchange/test_impl.py\n+++ b/pandas/tests/exchange/test_impl.py\n@@ -5,12 +5,12 @@\n import pytest\n \n import pandas as pd\n-import pandas._testing as tm\n-from pandas.core.exchange.dataframe_protocol import (\n+from pandas._core.exchange.dataframe_protocol import (\n ColumnNullType,\n DtypeKind,\n )\n-from pandas.core.exchange.from_dataframe import from_dataframe\n+from pandas._core.exchange.from_dataframe import from_dataframe\n+import pandas._testing as tm\n \n test_data_categorical = {\n \"ordered\": pd.Categorical(list(\"testdata\") * 30, ordered=True),\ndiff --git a/pandas/tests/exchange/test_utils.py b/pandas/tests/exchange/test_utils.py\nindex 4c80ecf0d23a0..29e7260267963 100644\n--- a/pandas/tests/exchange/test_utils.py\n+++ b/pandas/tests/exchange/test_utils.py\n@@ -2,7 +2,7 @@\n import pytest\n \n import pandas as pd\n-from pandas.core.exchange.utils import dtype_to_arrow_c_fmt\n+from pandas._core.exchange.utils import dtype_to_arrow_c_fmt\n \n # TODO: use ArrowSchema to get reference C-string.\n # At the time, there is no way to access ArrowSchema holding a type format string\ndiff --git a/pandas/tests/extension/arrow/arrays.py b/pandas/tests/extension/arrow/arrays.py\nindex 26b94ebe5a8da..1dc795e5801e8 100644\n--- a/pandas/tests/extension/arrow/arrays.py\n+++ b/pandas/tests/extension/arrow/arrays.py\n@@ -17,14 +17,14 @@\n from pandas._typing import type_t\n \n import pandas as pd\n+from pandas._core.arrays.arrow import ArrowExtensionArray as _ArrowExtensionArray\n+from pandas._core.construction import extract_array\n from pandas.api.extensions import (\n ExtensionDtype,\n register_extension_dtype,\n take,\n )\n from pandas.api.types import is_scalar\n-from pandas.core.arrays.arrow import ArrowExtensionArray as _ArrowExtensionArray\n-from pandas.core.construction import extract_array\n \n \n @register_extension_dtype\ndiff --git a/pandas/tests/extension/arrow/test_bool.py b/pandas/tests/extension/arrow/test_bool.py\nindex 0205b8aad9431..72421d24a589f 100644\n--- a/pandas/tests/extension/arrow/test_bool.py\n+++ b/pandas/tests/extension/arrow/test_bool.py\n@@ -97,7 +97,7 @@ class TestReduceBoolean(base.BaseBooleanReduceTests):\n \n def test_is_bool_dtype(data):\n assert is_bool_dtype(data)\n- assert pd.core.common.is_bool_indexer(data)\n+ assert pd._core.common.is_bool_indexer(data)\n s = pd.Series(range(len(data)))\n result = s[data]\n expected = s[np.asarray(data)]\ndiff --git a/pandas/tests/extension/base/casting.py b/pandas/tests/extension/base/casting.py\nindex 4987751f31dac..57d70b2a01213 100644\n--- a/pandas/tests/extension/base/casting.py\n+++ b/pandas/tests/extension/base/casting.py\n@@ -5,7 +5,7 @@\n import pandas.util._test_decorators as td\n \n import pandas as pd\n-from pandas.core.internals import ObjectBlock\n+from pandas._core.internals import ObjectBlock\n from pandas.tests.extension.base.base import BaseExtensionTests\n \n \ndiff --git a/pandas/tests/extension/base/constructors.py b/pandas/tests/extension/base/constructors.py\nindex b9f8f8512a995..5418f58fa0264 100644\n--- a/pandas/tests/extension/base/constructors.py\n+++ b/pandas/tests/extension/base/constructors.py\n@@ -2,8 +2,8 @@\n import pytest\n \n import pandas as pd\n+from pandas._core.internals.blocks import EABackedBlock\n from pandas.api.extensions import ExtensionArray\n-from pandas.core.internals.blocks import EABackedBlock\n from pandas.tests.extension.base.base import BaseExtensionTests\n \n \ndiff --git a/pandas/tests/extension/base/dim2.py b/pandas/tests/extension/base/dim2.py\nindex f71f3cf164bfc..5c306e4477ed4 100644\n--- a/pandas/tests/extension/base/dim2.py\n+++ b/pandas/tests/extension/base/dim2.py\n@@ -7,7 +7,7 @@\n from pandas._libs.missing import is_matching_na\n \n import pandas as pd\n-from pandas.core.arrays.integer import INT_STR_TO_DTYPE\n+from pandas._core.arrays.integer import INT_STR_TO_DTYPE\n from pandas.tests.extension.base.base import BaseExtensionTests\n \n \ndiff --git a/pandas/tests/extension/base/groupby.py b/pandas/tests/extension/base/groupby.py\nindex 711f1835446a5..e2414a4e10bda 100644\n--- a/pandas/tests/extension/base/groupby.py\n+++ b/pandas/tests/extension/base/groupby.py\n@@ -1,6 +1,6 @@\n import pytest\n \n-from pandas.core.dtypes.common import is_numeric_dtype\n+from pandas._core.dtypes.common import is_numeric_dtype\n \n import pandas as pd\n import pandas._testing as tm\ndiff --git a/pandas/tests/extension/base/interface.py b/pandas/tests/extension/base/interface.py\nindex 3e8a754c8c527..1183e92d7b89d 100644\n--- a/pandas/tests/extension/base/interface.py\n+++ b/pandas/tests/extension/base/interface.py\n@@ -1,7 +1,7 @@\n import numpy as np\n \n-from pandas.core.dtypes.common import is_extension_array_dtype\n-from pandas.core.dtypes.dtypes import ExtensionDtype\n+from pandas._core.dtypes.common import is_extension_array_dtype\n+from pandas._core.dtypes.dtypes import ExtensionDtype\n \n import pandas as pd\n import pandas._testing as tm\ndiff --git a/pandas/tests/extension/base/methods.py b/pandas/tests/extension/base/methods.py\nindex 6e9130b18e94f..04e3f5a7567a8 100644\n--- a/pandas/tests/extension/base/methods.py\n+++ b/pandas/tests/extension/base/methods.py\n@@ -4,11 +4,11 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import is_bool_dtype\n+from pandas._core.dtypes.common import is_bool_dtype\n \n import pandas as pd\n+from pandas._core.sorting import nargsort\n import pandas._testing as tm\n-from pandas.core.sorting import nargsort\n from pandas.tests.extension.base.base import BaseExtensionTests\n \n \n@@ -50,7 +50,7 @@ def test_value_counts_with_normalize(self, data):\n expected = pd.Series(0.0, index=result.index)\n expected[result > 0] = 1 / len(values)\n \n- if isinstance(data.dtype, pd.core.dtypes.dtypes.BaseMaskedDtype):\n+ if isinstance(data.dtype, pd._core.dtypes.dtypes.BaseMaskedDtype):\n # TODO(GH#44692): avoid special-casing\n expected = expected.astype(\"Float64\")\n \ndiff --git a/pandas/tests/extension/base/ops.py b/pandas/tests/extension/base/ops.py\nindex a1d232b737da7..2ddbc7a281470 100644\n--- a/pandas/tests/extension/base/ops.py\n+++ b/pandas/tests/extension/base/ops.py\n@@ -4,8 +4,8 @@\n import pytest\n \n import pandas as pd\n+from pandas._core import ops\n import pandas._testing as tm\n-from pandas.core import ops\n from pandas.tests.extension.base.base import BaseExtensionTests\n \n \ndiff --git a/pandas/tests/extension/base/reshaping.py b/pandas/tests/extension/base/reshaping.py\nindex babb2868a4421..8ce1f1c7be1ee 100644\n--- a/pandas/tests/extension/base/reshaping.py\n+++ b/pandas/tests/extension/base/reshaping.py\n@@ -4,9 +4,9 @@\n import pytest\n \n import pandas as pd\n+from pandas._core.internals.blocks import EABackedBlock\n import pandas._testing as tm\n from pandas.api.extensions import ExtensionArray\n-from pandas.core.internals.blocks import EABackedBlock\n from pandas.tests.extension.base.base import BaseExtensionTests\n \n \ndiff --git a/pandas/tests/extension/base/setitem.py b/pandas/tests/extension/base/setitem.py\nindex 04fa3c11a6c40..5a98e54b9ab35 100644\n--- a/pandas/tests/extension/base/setitem.py\n+++ b/pandas/tests/extension/base/setitem.py\n@@ -1,7 +1,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.dtypes import (\n+from pandas._core.dtypes.dtypes import (\n DatetimeTZDtype,\n IntervalDtype,\n PandasDtype,\n@@ -9,8 +9,8 @@\n )\n \n import pandas as pd\n+from pandas._core.arrays import IntervalArray\n import pandas._testing as tm\n-from pandas.core.arrays import IntervalArray\n from pandas.tests.extension.base.base import BaseExtensionTests\n \n \n@@ -397,7 +397,7 @@ def test_setitem_frame_2d_values(self, data):\n \n # Avoiding using_array_manager fixture\n # https://github.com/pandas-dev/pandas/pull/44514#discussion_r754002410\n- using_array_manager = isinstance(df._mgr, pd.core.internals.ArrayManager)\n+ using_array_manager = isinstance(df._mgr, pd._core.internals.ArrayManager)\n \n blk_data = df._mgr.arrays[0]\n \ndiff --git a/pandas/tests/extension/date/array.py b/pandas/tests/extension/date/array.py\nindex eca935cdc9128..207c2104fd5ea 100644\n--- a/pandas/tests/extension/date/array.py\n+++ b/pandas/tests/extension/date/array.py\n@@ -15,7 +15,7 @@\n PositionalIndexer,\n )\n \n-from pandas.core.dtypes.dtypes import register_extension_dtype\n+from pandas._core.dtypes.dtypes import register_extension_dtype\n \n from pandas.api.extensions import (\n ExtensionArray,\ndiff --git a/pandas/tests/extension/decimal/array.py b/pandas/tests/extension/decimal/array.py\nindex 6eaa90d7b868a..6b3d60eb4018f 100644\n--- a/pandas/tests/extension/decimal/array.py\n+++ b/pandas/tests/extension/decimal/array.py\n@@ -9,14 +9,21 @@\n \n from pandas._typing import type_t\n \n-from pandas.core.dtypes.base import ExtensionDtype\n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.base import ExtensionDtype\n+from pandas._core.dtypes.common import (\n is_dtype_equal,\n is_float,\n pandas_dtype,\n )\n \n import pandas as pd\n+from pandas._core import arraylike\n+from pandas._core.arraylike import OpsMixin\n+from pandas._core.arrays import (\n+ ExtensionArray,\n+ ExtensionScalarOpsMixin,\n+)\n+from pandas._core.indexers import check_array_indexer\n from pandas.api.extensions import (\n no_default,\n register_extension_dtype,\n@@ -25,13 +32,6 @@\n is_list_like,\n is_scalar,\n )\n-from pandas.core import arraylike\n-from pandas.core.arraylike import OpsMixin\n-from pandas.core.arrays import (\n- ExtensionArray,\n- ExtensionScalarOpsMixin,\n-)\n-from pandas.core.indexers import check_array_indexer\n \n \n @register_extension_dtype\n@@ -272,7 +272,7 @@ def convert_values(param):\n return np.asarray(res, dtype=bool)\n \n def value_counts(self, dropna: bool = True):\n- from pandas.core.algorithms import value_counts\n+ from pandas._core.algorithms import value_counts\n \n return value_counts(self.to_numpy(), dropna=dropna)\n \ndiff --git a/pandas/tests/extension/json/array.py b/pandas/tests/extension/json/array.py\nindex 125a0aee2089d..5a9a1a044876d 100644\n--- a/pandas/tests/extension/json/array.py\n+++ b/pandas/tests/extension/json/array.py\n@@ -31,19 +31,19 @@\n \n from pandas._typing import type_t\n \n-from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike\n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.cast import construct_1d_object_array_from_listlike\n+from pandas._core.dtypes.common import (\n is_bool_dtype,\n is_list_like,\n pandas_dtype,\n )\n \n import pandas as pd\n+from pandas._core.indexers import unpack_tuple_and_ellipses\n from pandas.api.extensions import (\n ExtensionArray,\n ExtensionDtype,\n )\n-from pandas.core.indexers import unpack_tuple_and_ellipses\n \n \n class JSONDtype(ExtensionDtype):\n@@ -194,7 +194,7 @@ def astype(self, dtype, copy=True):\n # NumPy has issues when all the dicts are the same length.\n # np.array([UserDict(...), UserDict(...)]) fails,\n # but np.array([{...}, {...}]) works, so cast.\n- from pandas.core.arrays.string_ import StringDtype\n+ from pandas._core.arrays.string_ import StringDtype\n \n dtype = pandas_dtype(dtype)\n # needed to add this check for the Series constructor\ndiff --git a/pandas/tests/extension/list/array.py b/pandas/tests/extension/list/array.py\nindex f281a0f82e0e7..ec2061cef7f2a 100644\n--- a/pandas/tests/extension/list/array.py\n+++ b/pandas/tests/extension/list/array.py\n@@ -13,14 +13,14 @@\n \n from pandas._typing import type_t\n \n-from pandas.core.dtypes.base import ExtensionDtype\n+from pandas._core.dtypes.base import ExtensionDtype\n \n import pandas as pd\n+from pandas._core.arrays import ExtensionArray\n from pandas.api.types import (\n is_object_dtype,\n is_string_dtype,\n )\n-from pandas.core.arrays import ExtensionArray\n \n \n class ListDtype(ExtensionDtype):\ndiff --git a/pandas/tests/extension/test_arrow.py b/pandas/tests/extension/test_arrow.py\nindex 06ce6901effc7..88a09dd4d7b36 100644\n--- a/pandas/tests/extension/test_arrow.py\n+++ b/pandas/tests/extension/test_arrow.py\n@@ -32,7 +32,7 @@\n \n pa = pytest.importorskip(\"pyarrow\", minversion=\"1.0.1\")\n \n-from pandas.core.arrays.arrow.dtype import ArrowDtype # isort:skip\n+from pandas._core.arrays.arrow.dtype import ArrowDtype # isort:skip\n \n \n @pytest.fixture(params=tm.ALL_PYARROW_DTYPES, ids=str)\ndiff --git a/pandas/tests/extension/test_boolean.py b/pandas/tests/extension/test_boolean.py\nindex dd067102aba6c..c37a7b6a35164 100644\n--- a/pandas/tests/extension/test_boolean.py\n+++ b/pandas/tests/extension/test_boolean.py\n@@ -17,8 +17,8 @@\n import pytest\n \n import pandas as pd\n+from pandas._core.arrays.boolean import BooleanDtype\n import pandas._testing as tm\n-from pandas.core.arrays.boolean import BooleanDtype\n from pandas.tests.extension import base\n \n \ndiff --git a/pandas/tests/extension/test_common.py b/pandas/tests/extension/test_common.py\nindex 62bc250193564..5c28bdd7ada23 100644\n--- a/pandas/tests/extension/test_common.py\n+++ b/pandas/tests/extension/test_common.py\n@@ -1,12 +1,12 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes import dtypes\n-from pandas.core.dtypes.common import is_extension_array_dtype\n+from pandas._core.dtypes import dtypes\n+from pandas._core.dtypes.common import is_extension_array_dtype\n \n import pandas as pd\n+from pandas._core.arrays import ExtensionArray\n import pandas._testing as tm\n-from pandas.core.arrays import ExtensionArray\n \n \n class DummyDtype(dtypes.ExtensionDtype):\ndiff --git a/pandas/tests/extension/test_datetime.py b/pandas/tests/extension/test_datetime.py\nindex 92796c604333d..30f57dedfd776 100644\n--- a/pandas/tests/extension/test_datetime.py\n+++ b/pandas/tests/extension/test_datetime.py\n@@ -16,10 +16,10 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.dtypes import DatetimeTZDtype\n+from pandas._core.dtypes.dtypes import DatetimeTZDtype\n \n import pandas as pd\n-from pandas.core.arrays import DatetimeArray\n+from pandas._core.arrays import DatetimeArray\n from pandas.tests.extension import base\n \n \ndiff --git a/pandas/tests/extension/test_extension.py b/pandas/tests/extension/test_extension.py\nindex a4b1a4b43ef2b..4956f4f4597e5 100644\n--- a/pandas/tests/extension/test_extension.py\n+++ b/pandas/tests/extension/test_extension.py\n@@ -4,8 +4,8 @@\n import numpy as np\n import pytest\n \n+from pandas._core.arrays import ExtensionArray\n import pandas._testing as tm\n-from pandas.core.arrays import ExtensionArray\n \n \n class MyEA(ExtensionArray):\ndiff --git a/pandas/tests/extension/test_external_block.py b/pandas/tests/extension/test_external_block.py\nindex 13dec96b144ff..dd3d30abfed4c 100644\n--- a/pandas/tests/extension/test_external_block.py\n+++ b/pandas/tests/extension/test_external_block.py\n@@ -5,8 +5,8 @@\n import pandas.util._test_decorators as td\n \n import pandas as pd\n-from pandas.core.internals import BlockManager\n-from pandas.core.internals.blocks import ExtensionBlock\n+from pandas._core.internals import BlockManager\n+from pandas._core.internals.blocks import ExtensionBlock\n \n pytestmark = td.skip_array_manager_invalid_test\n \ndiff --git a/pandas/tests/extension/test_floating.py b/pandas/tests/extension/test_floating.py\nindex ff0ff7399e3e6..c281669128a19 100644\n--- a/pandas/tests/extension/test_floating.py\n+++ b/pandas/tests/extension/test_floating.py\n@@ -16,15 +16,15 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import is_extension_array_dtype\n+from pandas._core.dtypes.common import is_extension_array_dtype\n \n import pandas as pd\n-import pandas._testing as tm\n-from pandas.api.types import is_float_dtype\n-from pandas.core.arrays.floating import (\n+from pandas._core.arrays.floating import (\n Float32Dtype,\n Float64Dtype,\n )\n+import pandas._testing as tm\n+from pandas.api.types import is_float_dtype\n from pandas.tests.extension import base\n \n \ndiff --git a/pandas/tests/extension/test_integer.py b/pandas/tests/extension/test_integer.py\nindex a6cf820dc7609..75bf89ea17af1 100644\n--- a/pandas/tests/extension/test_integer.py\n+++ b/pandas/tests/extension/test_integer.py\n@@ -17,12 +17,7 @@\n import pytest\n \n import pandas as pd\n-import pandas._testing as tm\n-from pandas.api.types import (\n- is_extension_array_dtype,\n- is_integer_dtype,\n-)\n-from pandas.core.arrays.integer import (\n+from pandas._core.arrays.integer import (\n Int8Dtype,\n Int16Dtype,\n Int32Dtype,\n@@ -32,6 +27,11 @@\n UInt32Dtype,\n UInt64Dtype,\n )\n+import pandas._testing as tm\n+from pandas.api.types import (\n+ is_extension_array_dtype,\n+ is_integer_dtype,\n+)\n from pandas.tests.extension import base\n \n \ndiff --git a/pandas/tests/extension/test_interval.py b/pandas/tests/extension/test_interval.py\nindex eb307d964d736..460fca3f772cc 100644\n--- a/pandas/tests/extension/test_interval.py\n+++ b/pandas/tests/extension/test_interval.py\n@@ -16,13 +16,13 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.dtypes import IntervalDtype\n+from pandas._core.dtypes.dtypes import IntervalDtype\n \n from pandas import (\n Interval,\n Series,\n )\n-from pandas.core.arrays import IntervalArray\n+from pandas._core.arrays import IntervalArray\n from pandas.tests.extension import base\n \n \ndiff --git a/pandas/tests/extension/test_numpy.py b/pandas/tests/extension/test_numpy.py\nindex 148059a6a16f3..4220c67194653 100644\n--- a/pandas/tests/extension/test_numpy.py\n+++ b/pandas/tests/extension/test_numpy.py\n@@ -18,16 +18,16 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.cast import can_hold_element\n-from pandas.core.dtypes.dtypes import (\n+from pandas._core.dtypes.cast import can_hold_element\n+from pandas._core.dtypes.dtypes import (\n ExtensionDtype,\n PandasDtype,\n )\n \n import pandas as pd\n+from pandas._core.arrays.numpy_ import PandasArray\n+from pandas._core.internals import blocks\n import pandas._testing as tm\n-from pandas.core.arrays.numpy_ import PandasArray\n-from pandas.core.internals import blocks\n from pandas.tests.extension import base\n \n \ndiff --git a/pandas/tests/extension/test_period.py b/pandas/tests/extension/test_period.py\nindex 06b372abf66f5..be338efd00377 100644\n--- a/pandas/tests/extension/test_period.py\n+++ b/pandas/tests/extension/test_period.py\n@@ -18,10 +18,10 @@\n \n from pandas._libs import iNaT\n \n-from pandas.core.dtypes.dtypes import PeriodDtype\n+from pandas._core.dtypes.dtypes import PeriodDtype\n \n import pandas as pd\n-from pandas.core.arrays import PeriodArray\n+from pandas._core.arrays import PeriodArray\n from pandas.tests.extension import base\n \n \ndiff --git a/pandas/tests/extension/test_sparse.py b/pandas/tests/extension/test_sparse.py\nindex d13f6dab1cc9b..bb7aea387cce0 100644\n--- a/pandas/tests/extension/test_sparse.py\n+++ b/pandas/tests/extension/test_sparse.py\n@@ -20,7 +20,7 @@\n from pandas.compat import np_version_under1p20\n from pandas.errors import PerformanceWarning\n \n-from pandas.core.dtypes.common import is_object_dtype\n+from pandas._core.dtypes.common import is_object_dtype\n \n import pandas as pd\n from pandas import SparseDtype\ndiff --git a/pandas/tests/extension/test_string.py b/pandas/tests/extension/test_string.py\nindex 8a8bdee90e467..37cf530d5c5f3 100644\n--- a/pandas/tests/extension/test_string.py\n+++ b/pandas/tests/extension/test_string.py\n@@ -22,9 +22,9 @@\n from pandas.errors import PerformanceWarning\n \n import pandas as pd\n+from pandas._core.arrays import ArrowStringArray\n+from pandas._core.arrays.string_ import StringDtype\n import pandas._testing as tm\n-from pandas.core.arrays import ArrowStringArray\n-from pandas.core.arrays.string_ import StringDtype\n from pandas.tests.extension import base\n \n \ndiff --git a/pandas/tests/frame/constructors/test_from_dict.py b/pandas/tests/frame/constructors/test_from_dict.py\nindex 7c2b009673bb7..a085a439573b1 100644\n--- a/pandas/tests/frame/constructors/test_from_dict.py\n+++ b/pandas/tests/frame/constructors/test_from_dict.py\n@@ -9,8 +9,8 @@\n MultiIndex,\n Series,\n )\n+from pandas._core.construction import create_series_with_explicit_dtype\n import pandas._testing as tm\n-from pandas.core.construction import create_series_with_explicit_dtype\n \n \n class TestFromDict:\ndiff --git a/pandas/tests/frame/indexing/test_getitem.py b/pandas/tests/frame/indexing/test_getitem.py\nindex 7994c56f8d68b..e167961610839 100644\n--- a/pandas/tests/frame/indexing/test_getitem.py\n+++ b/pandas/tests/frame/indexing/test_getitem.py\n@@ -17,8 +17,8 @@\n get_dummies,\n period_range,\n )\n+from pandas._core.arrays import SparseArray\n import pandas._testing as tm\n-from pandas.core.arrays import SparseArray\n \n \n class TestGetitem:\ndiff --git a/pandas/tests/frame/indexing/test_indexing.py b/pandas/tests/frame/indexing/test_indexing.py\nindex 0fbf375e441ac..350338ec5257c 100644\n--- a/pandas/tests/frame/indexing/test_indexing.py\n+++ b/pandas/tests/frame/indexing/test_indexing.py\n@@ -14,7 +14,7 @@\n )\n import pandas.util._test_decorators as td\n \n-from pandas.core.dtypes.common import is_integer\n+from pandas._core.dtypes.common import is_integer\n \n import pandas as pd\n from pandas import (\n@@ -1221,7 +1221,7 @@ def test_iloc_setitem_nullable_2d_values(self):\n df.loc[:] = df.values[:, ::-1]\n tm.assert_frame_equal(df, orig)\n \n- df.loc[:] = pd.core.arrays.PandasArray(df.values[:, ::-1])\n+ df.loc[:] = pd._core.arrays.PandasArray(df.values[:, ::-1])\n tm.assert_frame_equal(df, orig)\n \n df.iloc[:] = df.iloc[:, :]\ndiff --git a/pandas/tests/frame/indexing/test_set_value.py b/pandas/tests/frame/indexing/test_set_value.py\nindex 7b68566bab225..bdff9ef4e1e51 100644\n--- a/pandas/tests/frame/indexing/test_set_value.py\n+++ b/pandas/tests/frame/indexing/test_set_value.py\n@@ -1,6 +1,6 @@\n import numpy as np\n \n-from pandas.core.dtypes.common import is_float_dtype\n+from pandas._core.dtypes.common import is_float_dtype\n \n from pandas import (\n DataFrame,\ndiff --git a/pandas/tests/frame/indexing/test_setitem.py b/pandas/tests/frame/indexing/test_setitem.py\nindex a59d7d4f3bd45..598d93038267f 100644\n--- a/pandas/tests/frame/indexing/test_setitem.py\n+++ b/pandas/tests/frame/indexing/test_setitem.py\n@@ -5,13 +5,13 @@\n \n import pandas.util._test_decorators as td\n \n-from pandas.core.dtypes.base import _registry as ea_registry\n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.base import _registry as ea_registry\n+from pandas._core.dtypes.common import (\n is_categorical_dtype,\n is_interval_dtype,\n is_object_dtype,\n )\n-from pandas.core.dtypes.dtypes import (\n+from pandas._core.dtypes.dtypes import (\n CategoricalDtype,\n DatetimeTZDtype,\n IntervalDtype,\n@@ -37,8 +37,8 @@\n notna,\n period_range,\n )\n+from pandas._core.arrays import SparseArray\n import pandas._testing as tm\n-from pandas.core.arrays import SparseArray\n \n from pandas.tseries.offsets import BDay\n \ndiff --git a/pandas/tests/frame/indexing/test_where.py b/pandas/tests/frame/indexing/test_where.py\nindex 9d004613116b8..0b8038289fad0 100644\n--- a/pandas/tests/frame/indexing/test_where.py\n+++ b/pandas/tests/frame/indexing/test_where.py\n@@ -6,7 +6,7 @@\n \n from pandas.compat import np_version_under1p20\n \n-from pandas.core.dtypes.common import is_scalar\n+from pandas._core.dtypes.common import is_scalar\n \n import pandas as pd\n from pandas import (\ndiff --git a/pandas/tests/frame/methods/test_astype.py b/pandas/tests/frame/methods/test_astype.py\nindex 6d343de9f5d3a..1453c6d6eae32 100644\n--- a/pandas/tests/frame/methods/test_astype.py\n+++ b/pandas/tests/frame/methods/test_astype.py\n@@ -21,8 +21,8 @@\n date_range,\n option_context,\n )\n+from pandas._core.api import UInt64Index\n import pandas._testing as tm\n-from pandas.core.api import UInt64Index\n \n \n def _check_cast(df, v):\n@@ -759,7 +759,7 @@ def test_astype_categorical_to_string_missing(self):\n tm.assert_frame_equal(result, expected)\n \n \n-class IntegerArrayNoCopy(pd.core.arrays.IntegerArray):\n+class IntegerArrayNoCopy(pd._core.arrays.IntegerArray):\n # GH 42501\n \n def copy(self):\ndiff --git a/pandas/tests/frame/methods/test_combine_first.py b/pandas/tests/frame/methods/test_combine_first.py\nindex 783bef3206d58..2cce822a0ae17 100644\n--- a/pandas/tests/frame/methods/test_combine_first.py\n+++ b/pandas/tests/frame/methods/test_combine_first.py\n@@ -3,7 +3,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.cast import (\n+from pandas._core.dtypes.cast import (\n find_common_type,\n is_dtype_equal,\n )\ndiff --git a/pandas/tests/frame/methods/test_dtypes.py b/pandas/tests/frame/methods/test_dtypes.py\nindex 31592f987f04d..76f197da4f996 100644\n--- a/pandas/tests/frame/methods/test_dtypes.py\n+++ b/pandas/tests/frame/methods/test_dtypes.py\n@@ -2,7 +2,7 @@\n \n import numpy as np\n \n-from pandas.core.dtypes.dtypes import DatetimeTZDtype\n+from pandas._core.dtypes.dtypes import DatetimeTZDtype\n \n import pandas as pd\n from pandas import (\ndiff --git a/pandas/tests/frame/methods/test_get_numeric_data.py b/pandas/tests/frame/methods/test_get_numeric_data.py\nindex 8628b76f54b1d..c32a0a7c94a40 100644\n--- a/pandas/tests/frame/methods/test_get_numeric_data.py\n+++ b/pandas/tests/frame/methods/test_get_numeric_data.py\n@@ -8,8 +8,8 @@\n Series,\n Timestamp,\n )\n+from pandas._core.arrays import IntervalArray\n import pandas._testing as tm\n-from pandas.core.arrays import IntervalArray\n \n \n class TestGetNumericData:\ndiff --git a/pandas/tests/frame/methods/test_join.py b/pandas/tests/frame/methods/test_join.py\nindex 0935856fb223a..226f970a70086 100644\n--- a/pandas/tests/frame/methods/test_join.py\n+++ b/pandas/tests/frame/methods/test_join.py\n@@ -13,8 +13,8 @@\n date_range,\n period_range,\n )\n+from pandas._core.reshape.concat import concat\n import pandas._testing as tm\n-from pandas.core.reshape.concat import concat\n \n \n @pytest.fixture\ndiff --git a/pandas/tests/frame/methods/test_reindex.py b/pandas/tests/frame/methods/test_reindex.py\nindex 8575e7895ae5a..447478c2ce92a 100644\n--- a/pandas/tests/frame/methods/test_reindex.py\n+++ b/pandas/tests/frame/methods/test_reindex.py\n@@ -21,9 +21,9 @@\n date_range,\n isna,\n )\n+import pandas._core.common as com\n import pandas._testing as tm\n from pandas.api.types import CategoricalDtype as CDT\n-import pandas.core.common as com\n \n \n class TestReindexSetIndex:\ndiff --git a/pandas/tests/frame/methods/test_reset_index.py b/pandas/tests/frame/methods/test_reset_index.py\nindex bd168e4f14558..9dfef67d39086 100644\n--- a/pandas/tests/frame/methods/test_reset_index.py\n+++ b/pandas/tests/frame/methods/test_reset_index.py\n@@ -4,7 +4,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_float_dtype,\n is_integer_dtype,\n )\ndiff --git a/pandas/tests/frame/methods/test_sample.py b/pandas/tests/frame/methods/test_sample.py\nindex 901987a953d82..304418919fdaf 100644\n--- a/pandas/tests/frame/methods/test_sample.py\n+++ b/pandas/tests/frame/methods/test_sample.py\n@@ -6,8 +6,8 @@\n Index,\n Series,\n )\n+import pandas._core.common as com\n import pandas._testing as tm\n-import pandas.core.common as com\n \n \n class TestSample:\ndiff --git a/pandas/tests/frame/methods/test_select_dtypes.py b/pandas/tests/frame/methods/test_select_dtypes.py\nindex 9da6b61e67603..5ef821e81f982 100644\n--- a/pandas/tests/frame/methods/test_select_dtypes.py\n+++ b/pandas/tests/frame/methods/test_select_dtypes.py\n@@ -1,15 +1,15 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.dtypes import ExtensionDtype\n+from pandas._core.dtypes.dtypes import ExtensionDtype\n \n import pandas as pd\n from pandas import (\n DataFrame,\n Timestamp,\n )\n+from pandas._core.arrays import ExtensionArray\n import pandas._testing as tm\n-from pandas.core.arrays import ExtensionArray\n \n \n class DummyDtype(ExtensionDtype):\ndiff --git a/pandas/tests/frame/methods/test_to_csv.py b/pandas/tests/frame/methods/test_to_csv.py\nindex df7bc04202e39..c39015aa9cbb8 100644\n--- a/pandas/tests/frame/methods/test_to_csv.py\n+++ b/pandas/tests/frame/methods/test_to_csv.py\n@@ -19,8 +19,8 @@\n read_csv,\n to_datetime,\n )\n+import pandas._core.common as com\n import pandas._testing as tm\n-import pandas.core.common as com\n \n from pandas.io.common import get_handle\n \ndiff --git a/pandas/tests/frame/methods/test_to_dict_of_blocks.py b/pandas/tests/frame/methods/test_to_dict_of_blocks.py\nindex c81bed9d93cc4..3325160819607 100644\n--- a/pandas/tests/frame/methods/test_to_dict_of_blocks.py\n+++ b/pandas/tests/frame/methods/test_to_dict_of_blocks.py\n@@ -6,8 +6,8 @@\n DataFrame,\n MultiIndex,\n )\n+from pandas._core.arrays import PandasArray\n import pandas._testing as tm\n-from pandas.core.arrays import PandasArray\n \n pytestmark = td.skip_array_manager_invalid_test\n \ndiff --git a/pandas/tests/frame/methods/test_truncate.py b/pandas/tests/frame/methods/test_truncate.py\nindex bfee3edc085d8..ed2e76f4aed98 100644\n--- a/pandas/tests/frame/methods/test_truncate.py\n+++ b/pandas/tests/frame/methods/test_truncate.py\n@@ -8,8 +8,8 @@\n Series,\n date_range,\n )\n+from pandas._core.api import Int64Index\n import pandas._testing as tm\n-from pandas.core.api import Int64Index\n \n \n class TestDataFrameTruncate:\ndiff --git a/pandas/tests/frame/test_arithmetic.py b/pandas/tests/frame/test_arithmetic.py\nindex 0864032b741c9..972193b890829 100644\n--- a/pandas/tests/frame/test_arithmetic.py\n+++ b/pandas/tests/frame/test_arithmetic.py\n@@ -17,13 +17,13 @@\n MultiIndex,\n Series,\n )\n-import pandas._testing as tm\n-import pandas.core.common as com\n-from pandas.core.computation import expressions as expr\n-from pandas.core.computation.expressions import (\n+import pandas._core.common as com\n+from pandas._core.computation import expressions as expr\n+from pandas._core.computation.expressions import (\n _MIN_ELEMENTS,\n NUMEXPR_INSTALLED,\n )\n+import pandas._testing as tm\n from pandas.tests.frame.common import (\n _check_mixed_float,\n _check_mixed_int,\n@@ -1783,7 +1783,7 @@ def test_alignment_non_pandas(self, val):\n columns = [\"X\", \"Y\", \"Z\"]\n df = DataFrame(np.random.randn(3, 3), index=index, columns=columns)\n \n- align = pd.core.ops.align_method_FRAME\n+ align = pd._core.ops.align_method_FRAME\n \n expected = DataFrame({\"X\": val, \"Y\": val, \"Z\": val}, index=df.index)\n tm.assert_frame_equal(align(df, val, \"index\")[1], expected)\n@@ -1799,7 +1799,7 @@ def test_alignment_non_pandas_length_mismatch(self, val):\n columns = [\"X\", \"Y\", \"Z\"]\n df = DataFrame(np.random.randn(3, 3), index=index, columns=columns)\n \n- align = pd.core.ops.align_method_FRAME\n+ align = pd._core.ops.align_method_FRAME\n # length mismatch\n msg = \"Unable to coerce to Series, length must be 3: given 2\"\n with pytest.raises(ValueError, match=msg):\n@@ -1813,7 +1813,7 @@ def test_alignment_non_pandas_index_columns(self):\n columns = [\"X\", \"Y\", \"Z\"]\n df = DataFrame(np.random.randn(3, 3), index=index, columns=columns)\n \n- align = pd.core.ops.align_method_FRAME\n+ align = pd._core.ops.align_method_FRAME\n val = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n tm.assert_frame_equal(\n align(df, val, \"index\")[1],\ndiff --git a/pandas/tests/frame/test_block_internals.py b/pandas/tests/frame/test_block_internals.py\nindex 8aa0e980b01c4..b757ece34e04f 100644\n--- a/pandas/tests/frame/test_block_internals.py\n+++ b/pandas/tests/frame/test_block_internals.py\n@@ -20,11 +20,11 @@\n date_range,\n option_context,\n )\n-import pandas._testing as tm\n-from pandas.core.internals import (\n+from pandas._core.internals import (\n NumericBlock,\n ObjectBlock,\n )\n+import pandas._testing as tm\n \n # Segregated collection of methods that require the BlockManager internal data\n # structure\ndiff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py\nindex f06641002e039..d524348dae359 100644\n--- a/pandas/tests/frame/test_constructors.py\n+++ b/pandas/tests/frame/test_constructors.py\n@@ -20,8 +20,8 @@\n \n import pandas.util._test_decorators as td\n \n-from pandas.core.dtypes.common import is_integer_dtype\n-from pandas.core.dtypes.dtypes import (\n+from pandas._core.dtypes.common import is_integer_dtype\n+from pandas._core.dtypes.dtypes import (\n DatetimeTZDtype,\n IntervalDtype,\n PandasDtype,\n@@ -46,6 +46,7 @@\n date_range,\n isna,\n )\n+from pandas._core.api import Int64Index\n import pandas._testing as tm\n from pandas.arrays import (\n DatetimeArray,\n@@ -54,7 +55,6 @@\n SparseArray,\n TimedeltaArray,\n )\n-from pandas.core.api import Int64Index\n \n MIXED_FLOAT_DTYPES = [\"float16\", \"float32\", \"float64\"]\n MIXED_INT_DTYPES = [\ndiff --git a/pandas/tests/frame/test_query_eval.py b/pandas/tests/frame/test_query_eval.py\nindex 35335c54cd41e..771f210153aed 100644\n--- a/pandas/tests/frame/test_query_eval.py\n+++ b/pandas/tests/frame/test_query_eval.py\n@@ -14,8 +14,8 @@\n Series,\n date_range,\n )\n+from pandas._core.computation.check import NUMEXPR_INSTALLED\n import pandas._testing as tm\n-from pandas.core.computation.check import NUMEXPR_INSTALLED\n \n \n @pytest.fixture(params=[\"python\", \"pandas\"], ids=lambda x: x)\ndiff --git a/pandas/tests/frame/test_reductions.py b/pandas/tests/frame/test_reductions.py\nindex b4d3d1ae548b5..2988e7e6a930d 100644\n--- a/pandas/tests/frame/test_reductions.py\n+++ b/pandas/tests/frame/test_reductions.py\n@@ -11,7 +11,7 @@\n from pandas.compat import is_platform_windows\n import pandas.util._test_decorators as td\n \n-from pandas.core.dtypes.common import is_categorical_dtype\n+from pandas._core.dtypes.common import is_categorical_dtype\n \n import pandas as pd\n from pandas import (\n@@ -27,9 +27,9 @@\n to_datetime,\n to_timedelta,\n )\n+import pandas._core.algorithms as algorithms\n+import pandas._core.nanops as nanops\n import pandas._testing as tm\n-import pandas.core.algorithms as algorithms\n-import pandas.core.nanops as nanops\n \n \n def assert_stat_op_calc(\ndiff --git a/pandas/tests/frame/test_stack_unstack.py b/pandas/tests/frame/test_stack_unstack.py\nindex 69e5d5e3d5447..fadd4bd3cd91d 100644\n--- a/pandas/tests/frame/test_stack_unstack.py\n+++ b/pandas/tests/frame/test_stack_unstack.py\n@@ -17,8 +17,8 @@\n Timedelta,\n date_range,\n )\n+from pandas._core.reshape import reshape as reshape_lib\n import pandas._testing as tm\n-from pandas.core.reshape import reshape as reshape_lib\n \n \n class TestDataFrameReshape:\ndiff --git a/pandas/tests/frame/test_validate.py b/pandas/tests/frame/test_validate.py\nindex e99e0a6863848..f4885c9d44d59 100644\n--- a/pandas/tests/frame/test_validate.py\n+++ b/pandas/tests/frame/test_validate.py\n@@ -1,6 +1,6 @@\n import pytest\n \n-from pandas.core.frame import DataFrame\n+from pandas._core.frame import DataFrame\n \n \n @pytest.fixture\ndiff --git a/pandas/tests/generic/test_generic.py b/pandas/tests/generic/test_generic.py\nindex 80d9bde784018..871adebfdce8d 100644\n--- a/pandas/tests/generic/test_generic.py\n+++ b/pandas/tests/generic/test_generic.py\n@@ -6,7 +6,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import is_scalar\n+from pandas._core.dtypes.common import is_scalar\n \n from pandas import (\n DataFrame,\n@@ -364,7 +364,7 @@ def test_numpy_squeeze(self):\n \"ser\", [tm.makeFloatSeries(), tm.makeStringSeries(), tm.makeObjectSeries()]\n )\n def test_transpose_series(self, ser):\n- # calls implementation in pandas/core/base.py\n+ # calls implementation in pandas._core/base.py\n tm.assert_series_equal(ser.transpose(), ser)\n \n def test_transpose_frame(self):\ndiff --git a/pandas/tests/generic/test_label_or_level_utils.py b/pandas/tests/generic/test_label_or_level_utils.py\nindex d1c85d770621c..a161fdd7b1df1 100644\n--- a/pandas/tests/generic/test_label_or_level_utils.py\n+++ b/pandas/tests/generic/test_label_or_level_utils.py\n@@ -1,6 +1,6 @@\n import pytest\n \n-from pandas.core.dtypes.missing import array_equivalent\n+from pandas._core.dtypes.missing import array_equivalent\n \n import pandas as pd\n \ndiff --git a/pandas/tests/groupby/aggregate/test_aggregate.py b/pandas/tests/groupby/aggregate/test_aggregate.py\nindex d52b6ceaf8990..d6781f8f3778b 100644\n--- a/pandas/tests/groupby/aggregate/test_aggregate.py\n+++ b/pandas/tests/groupby/aggregate/test_aggregate.py\n@@ -11,7 +11,7 @@\n \n from pandas.errors import SpecificationError\n \n-from pandas.core.dtypes.common import is_integer_dtype\n+from pandas._core.dtypes.common import is_integer_dtype\n \n import pandas as pd\n from pandas import (\n@@ -22,8 +22,8 @@\n concat,\n to_datetime,\n )\n+from pandas._core.groupby.grouper import Grouping\n import pandas._testing as tm\n-from pandas.core.groupby.grouper import Grouping\n \n \n def test_groupby_agg_no_extra_calls():\ndiff --git a/pandas/tests/groupby/aggregate/test_cython.py b/pandas/tests/groupby/aggregate/test_cython.py\nindex 9631de7833cf4..bcf7b4a675f38 100644\n--- a/pandas/tests/groupby/aggregate/test_cython.py\n+++ b/pandas/tests/groupby/aggregate/test_cython.py\n@@ -5,7 +5,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_float_dtype,\n is_integer_dtype,\n )\ndiff --git a/pandas/tests/groupby/conftest.py b/pandas/tests/groupby/conftest.py\nindex 58d9e500554dd..bcae04c7c9516 100644\n--- a/pandas/tests/groupby/conftest.py\n+++ b/pandas/tests/groupby/conftest.py\n@@ -2,11 +2,11 @@\n import pytest\n \n from pandas import DataFrame\n-import pandas._testing as tm\n-from pandas.core.groupby.base import (\n+from pandas._core.groupby.base import (\n reduction_kernels,\n transformation_kernels,\n )\n+import pandas._testing as tm\n \n \n @pytest.fixture(params=[True, False])\ndiff --git a/pandas/tests/groupby/test_allowlist.py b/pandas/tests/groupby/test_allowlist.py\nindex e541abb368a02..5bc7754e9154d 100644\n--- a/pandas/tests/groupby/test_allowlist.py\n+++ b/pandas/tests/groupby/test_allowlist.py\n@@ -13,12 +13,12 @@\n Series,\n date_range,\n )\n-import pandas._testing as tm\n-from pandas.core.groupby.base import (\n+from pandas._core.groupby.base import (\n groupby_other_methods,\n reduction_kernels,\n transformation_kernels,\n )\n+import pandas._testing as tm\n \n AGG_FUNCTIONS = [\n \"sum\",\n@@ -429,11 +429,11 @@ def test_all_methods_categorized(mframe):\n Was a new method recently added?\n \n Every public method On Grouper must appear in exactly one the\n-following three lists defined in pandas.core.groupby.base:\n+following three lists defined in pandas._core.groupby.base:\n - `reduction_kernels`\n - `transformation_kernels`\n - `groupby_other_methods`\n-see the comments in pandas/core/groupby/base.py for guidance on\n+see the comments in pandas._core/groupby/base.py for guidance on\n how to fix this test.\n \"\"\"\n raise AssertionError(msg)\n@@ -448,7 +448,7 @@ def test_all_methods_categorized(mframe):\n are missing:\n {all_categorized - names}.\n \n-They're still defined in one of the lists that live in pandas/core/groupby/base.py.\n+They're still defined in one of the lists that live in pandas._core/groupby/base.py.\n If you removed a method, you should update them\n \"\"\"\n raise AssertionError(msg)\ndiff --git a/pandas/tests/groupby/test_apply.py b/pandas/tests/groupby/test_apply.py\nindex 4cfc3ea41543b..9cdba89b50da2 100644\n--- a/pandas/tests/groupby/test_apply.py\n+++ b/pandas/tests/groupby/test_apply.py\n@@ -15,8 +15,8 @@\n Series,\n bdate_range,\n )\n+from pandas._core.api import Int64Index\n import pandas._testing as tm\n-from pandas.core.api import Int64Index\n \n \n def test_apply_issues():\ndiff --git a/pandas/tests/groupby/test_function.py b/pandas/tests/groupby/test_function.py\nindex 7f24143920b84..4e5c9dc830d02 100644\n--- a/pandas/tests/groupby/test_function.py\n+++ b/pandas/tests/groupby/test_function.py\n@@ -16,8 +16,8 @@\n Timestamp,\n date_range,\n )\n+import pandas._core.nanops as nanops\n import pandas._testing as tm\n-import pandas.core.nanops as nanops\n from pandas.util import _test_decorators as td\n \n \ndiff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py\nindex 97e616ef14cef..895bdd8b2cc40 100644\n--- a/pandas/tests/groupby/test_groupby.py\n+++ b/pandas/tests/groupby/test_groupby.py\n@@ -25,10 +25,10 @@\n date_range,\n to_datetime,\n )\n+from pandas._core.arrays import BooleanArray\n+import pandas._core.common as com\n+from pandas._core.groupby.base import maybe_normalize_deprecated_kernels\n import pandas._testing as tm\n-from pandas.core.arrays import BooleanArray\n-import pandas.core.common as com\n-from pandas.core.groupby.base import maybe_normalize_deprecated_kernels\n \n \n def test_repr():\ndiff --git a/pandas/tests/groupby/test_groupby_subclass.py b/pandas/tests/groupby/test_groupby_subclass.py\nindex b665843728165..9bd175dab5c5c 100644\n--- a/pandas/tests/groupby/test_groupby_subclass.py\n+++ b/pandas/tests/groupby/test_groupby_subclass.py\n@@ -8,8 +8,8 @@\n Index,\n Series,\n )\n+from pandas._core.groupby.base import maybe_normalize_deprecated_kernels\n import pandas._testing as tm\n-from pandas.core.groupby.base import maybe_normalize_deprecated_kernels\n \n \n @pytest.mark.parametrize(\ndiff --git a/pandas/tests/groupby/test_grouping.py b/pandas/tests/groupby/test_grouping.py\nindex 6da07dafcda74..cbd5648b50c17 100644\n--- a/pandas/tests/groupby/test_grouping.py\n+++ b/pandas/tests/groupby/test_grouping.py\n@@ -13,12 +13,12 @@\n Timestamp,\n date_range,\n )\n-import pandas._testing as tm\n-from pandas.core.api import (\n+from pandas._core.api import (\n Float64Index,\n Int64Index,\n )\n-from pandas.core.groupby.grouper import Grouping\n+from pandas._core.groupby.grouper import Grouping\n+import pandas._testing as tm\n \n # selection\n # --------------------------------\n@@ -446,7 +446,7 @@ def test_groupby_grouper_f_sanity_checked(self):\n ts.groupby(lambda key: key[0:6])\n \n def test_grouping_error_on_multidim_input(self, df):\n- msg = \"Grouper for '<class 'pandas.core.frame.DataFrame'>' not 1-dimensional\"\n+ msg = \"Grouper for '<class 'pandas._core.frame.DataFrame'>' not 1-dimensional\"\n with pytest.raises(ValueError, match=msg):\n Grouping(df.index, df[[\"A\", \"A\"]])\n \ndiff --git a/pandas/tests/groupby/test_libgroupby.py b/pandas/tests/groupby/test_libgroupby.py\nindex cde9b36fd0bf4..f7169f465ff02 100644\n--- a/pandas/tests/groupby/test_libgroupby.py\n+++ b/pandas/tests/groupby/test_libgroupby.py\n@@ -9,7 +9,7 @@\n group_var,\n )\n \n-from pandas.core.dtypes.common import ensure_platform_int\n+from pandas._core.dtypes.common import ensure_platform_int\n \n from pandas import isna\n import pandas._testing as tm\ndiff --git a/pandas/tests/groupby/test_min_max.py b/pandas/tests/groupby/test_min_max.py\nindex b26ee057d2041..21ada3597c824 100644\n--- a/pandas/tests/groupby/test_min_max.py\n+++ b/pandas/tests/groupby/test_min_max.py\n@@ -9,8 +9,8 @@\n Index,\n Series,\n )\n+from pandas._core.api import Int64Index\n import pandas._testing as tm\n-from pandas.core.api import Int64Index\n \n \n def test_max_min_non_numeric():\ndiff --git a/pandas/tests/groupby/test_pipe.py b/pandas/tests/groupby/test_pipe.py\nindex 4f58bcb5ee763..c39709b5f6609 100644\n--- a/pandas/tests/groupby/test_pipe.py\n+++ b/pandas/tests/groupby/test_pipe.py\n@@ -5,8 +5,8 @@\n DataFrame,\n Index,\n )\n+from pandas._core.api import Int64Index\n import pandas._testing as tm\n-from pandas.core.api import Int64Index\n \n \n def test_pipe():\ndiff --git a/pandas/tests/groupby/test_timegrouper.py b/pandas/tests/groupby/test_timegrouper.py\nindex ae725cbb2b588..67e3b8941cdcd 100644\n--- a/pandas/tests/groupby/test_timegrouper.py\n+++ b/pandas/tests/groupby/test_timegrouper.py\n@@ -20,9 +20,9 @@\n date_range,\n offsets,\n )\n+from pandas._core.groupby.grouper import Grouper\n+from pandas._core.groupby.ops import BinGrouper\n import pandas._testing as tm\n-from pandas.core.groupby.grouper import Grouper\n-from pandas.core.groupby.ops import BinGrouper\n \n \n @pytest.fixture\ndiff --git a/pandas/tests/groupby/transform/test_transform.py b/pandas/tests/groupby/transform/test_transform.py\nindex 5c64ba3d9e266..ef2f9c77f682f 100644\n--- a/pandas/tests/groupby/transform/test_transform.py\n+++ b/pandas/tests/groupby/transform/test_transform.py\n@@ -4,7 +4,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n ensure_platform_int,\n is_timedelta64_dtype,\n )\n@@ -19,9 +19,9 @@\n concat,\n date_range,\n )\n+from pandas._core.groupby.base import maybe_normalize_deprecated_kernels\n+from pandas._core.groupby.generic import DataFrameGroupBy\n import pandas._testing as tm\n-from pandas.core.groupby.base import maybe_normalize_deprecated_kernels\n-from pandas.core.groupby.generic import DataFrameGroupBy\n \n \n def assert_fp_equal(a, b):\ndiff --git a/pandas/tests/indexes/base_class/test_setops.py b/pandas/tests/indexes/base_class/test_setops.py\nindex 87ffe99896199..d91005748feb4 100644\n--- a/pandas/tests/indexes/base_class/test_setops.py\n+++ b/pandas/tests/indexes/base_class/test_setops.py\n@@ -8,8 +8,8 @@\n Index,\n Series,\n )\n+from pandas._core.algorithms import safe_sort\n import pandas._testing as tm\n-from pandas.core.algorithms import safe_sort\n \n \n class TestIndexSetOps:\ndiff --git a/pandas/tests/indexes/categorical/test_category.py b/pandas/tests/indexes/categorical/test_category.py\nindex 06c00123566ba..ca8f52d2b844f 100644\n--- a/pandas/tests/indexes/categorical/test_category.py\n+++ b/pandas/tests/indexes/categorical/test_category.py\n@@ -9,11 +9,11 @@\n Categorical,\n CategoricalDtype,\n )\n-import pandas._testing as tm\n-from pandas.core.indexes.api import (\n+from pandas._core.indexes.api import (\n CategoricalIndex,\n Index,\n )\n+import pandas._testing as tm\n from pandas.tests.indexes.common import Base\n \n \ndiff --git a/pandas/tests/indexes/common.py b/pandas/tests/indexes/common.py\nindex 3f8c679c6162f..7ab35ddad0565 100644\n--- a/pandas/tests/indexes/common.py\n+++ b/pandas/tests/indexes/common.py\n@@ -8,11 +8,11 @@\n \n from pandas._libs.tslibs import Timestamp\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_datetime64tz_dtype,\n is_integer_dtype,\n )\n-from pandas.core.dtypes.dtypes import CategoricalDtype\n+from pandas._core.dtypes.dtypes import CategoricalDtype\n \n import pandas as pd\n from pandas import (\n@@ -27,14 +27,14 @@\n TimedeltaIndex,\n isna,\n )\n-import pandas._testing as tm\n-from pandas.core.api import ( # noqa:F401\n+from pandas._core.api import ( # noqa:F401\n Float64Index,\n Int64Index,\n NumericIndex,\n UInt64Index,\n )\n-from pandas.core.arrays import BaseMaskedArray\n+from pandas._core.arrays import BaseMaskedArray\n+import pandas._testing as tm\n \n \n class Base:\n@@ -307,7 +307,7 @@ def test_numpy_argsort(self, index):\n # pandas compatibility input validation - the\n # rest already perform separate (or no) such\n # validation via their 'values' attribute as\n- # defined in pandas.core.indexes/base.py - they\n+ # defined in pandas._core.indexes/base.py - they\n # cannot be changed at the moment due to\n # backwards compatibility concerns\n if isinstance(index, (CategoricalIndex, RangeIndex)):\ndiff --git a/pandas/tests/indexes/datetimes/methods/test_astype.py b/pandas/tests/indexes/datetimes/methods/test_astype.py\nindex e7823f0c90b1a..061a0d63dbbdb 100644\n--- a/pandas/tests/indexes/datetimes/methods/test_astype.py\n+++ b/pandas/tests/indexes/datetimes/methods/test_astype.py\n@@ -14,11 +14,11 @@\n Timestamp,\n date_range,\n )\n-import pandas._testing as tm\n-from pandas.core.api import (\n+from pandas._core.api import (\n Int64Index,\n UInt64Index,\n )\n+import pandas._testing as tm\n \n \n class TestDatetimeIndex:\ndiff --git a/pandas/tests/indexes/datetimes/test_constructors.py b/pandas/tests/indexes/datetimes/test_constructors.py\nindex e971e311e7d20..128dd3571cb55 100644\n--- a/pandas/tests/indexes/datetimes/test_constructors.py\n+++ b/pandas/tests/indexes/datetimes/test_constructors.py\n@@ -26,11 +26,11 @@\n offsets,\n to_datetime,\n )\n-import pandas._testing as tm\n-from pandas.core.arrays import (\n+from pandas._core.arrays import (\n DatetimeArray,\n period_array,\n )\n+import pandas._testing as tm\n \n if PY39:\n import zoneinfo\ndiff --git a/pandas/tests/indexes/datetimes/test_date_range.py b/pandas/tests/indexes/datetimes/test_date_range.py\nindex 377974a918ad9..c5d8950283728 100644\n--- a/pandas/tests/indexes/datetimes/test_date_range.py\n+++ b/pandas/tests/indexes/datetimes/test_date_range.py\n@@ -33,8 +33,8 @@\n date_range,\n offsets,\n )\n+from pandas._core.arrays.datetimes import generate_range\n import pandas._testing as tm\n-from pandas.core.arrays.datetimes import generate_range\n \n START, END = datetime(2009, 1, 1), datetime(2010, 1, 1)\n \ndiff --git a/pandas/tests/indexes/datetimes/test_misc.py b/pandas/tests/indexes/datetimes/test_misc.py\nindex d4a87e6a8b65c..6f6b4186b6a8e 100644\n--- a/pandas/tests/indexes/datetimes/test_misc.py\n+++ b/pandas/tests/indexes/datetimes/test_misc.py\n@@ -15,8 +15,8 @@\n date_range,\n offsets,\n )\n+from pandas._core.arrays import DatetimeArray\n import pandas._testing as tm\n-from pandas.core.arrays import DatetimeArray\n \n \n class TestDatetime64:\ndiff --git a/pandas/tests/indexes/datetimes/test_scalar_compat.py b/pandas/tests/indexes/datetimes/test_scalar_compat.py\nindex c60e56875bfcd..1c0d288326b01 100644\n--- a/pandas/tests/indexes/datetimes/test_scalar_compat.py\n+++ b/pandas/tests/indexes/datetimes/test_scalar_compat.py\n@@ -18,8 +18,8 @@\n Timestamp,\n date_range,\n )\n+from pandas._core.api import Float64Index\n import pandas._testing as tm\n-from pandas.core.api import Float64Index\n \n \n class TestDatetimeIndexOps:\ndiff --git a/pandas/tests/indexes/datetimes/test_setops.py b/pandas/tests/indexes/datetimes/test_setops.py\nindex e92d726867f32..67aa6edeaeb1b 100644\n--- a/pandas/tests/indexes/datetimes/test_setops.py\n+++ b/pandas/tests/indexes/datetimes/test_setops.py\n@@ -14,8 +14,8 @@\n bdate_range,\n date_range,\n )\n+from pandas._core.api import Int64Index\n import pandas._testing as tm\n-from pandas.core.api import Int64Index\n \n from pandas.tseries.offsets import (\n BMonthEnd,\ndiff --git a/pandas/tests/indexes/interval/test_astype.py b/pandas/tests/indexes/interval/test_astype.py\nindex 6751a383699bb..3d5181d683f9f 100644\n--- a/pandas/tests/indexes/interval/test_astype.py\n+++ b/pandas/tests/indexes/interval/test_astype.py\n@@ -3,7 +3,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.dtypes import (\n+from pandas._core.dtypes.dtypes import (\n CategoricalDtype,\n IntervalDtype,\n )\ndiff --git a/pandas/tests/indexes/interval/test_constructors.py b/pandas/tests/indexes/interval/test_constructors.py\nindex b57bcf7abc1e1..824e58a882dd6 100644\n--- a/pandas/tests/indexes/interval/test_constructors.py\n+++ b/pandas/tests/indexes/interval/test_constructors.py\n@@ -3,8 +3,8 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import is_categorical_dtype\n-from pandas.core.dtypes.dtypes import IntervalDtype\n+from pandas._core.dtypes.common import is_categorical_dtype\n+from pandas._core.dtypes.dtypes import IntervalDtype\n \n from pandas import (\n Categorical,\n@@ -17,13 +17,13 @@\n period_range,\n timedelta_range,\n )\n-import pandas._testing as tm\n-from pandas.core.api import (\n+from pandas._core.api import (\n Float64Index,\n Int64Index,\n )\n-from pandas.core.arrays import IntervalArray\n-import pandas.core.common as com\n+from pandas._core.arrays import IntervalArray\n+import pandas._core.common as com\n+import pandas._testing as tm\n \n \n @pytest.fixture(params=[None, \"foo\"])\ndiff --git a/pandas/tests/indexes/interval/test_formats.py b/pandas/tests/indexes/interval/test_formats.py\nindex 2d9b8c83c7ab2..f9cd606deed31 100644\n--- a/pandas/tests/indexes/interval/test_formats.py\n+++ b/pandas/tests/indexes/interval/test_formats.py\n@@ -9,8 +9,8 @@\n Timedelta,\n Timestamp,\n )\n+from pandas._core.api import Float64Index\n import pandas._testing as tm\n-from pandas.core.api import Float64Index\n \n \n class TestIntervalIndexRendering:\ndiff --git a/pandas/tests/indexes/interval/test_interval.py b/pandas/tests/indexes/interval/test_interval.py\nindex 4e33c3abd3252..ddf68eecef43f 100644\n--- a/pandas/tests/indexes/interval/test_interval.py\n+++ b/pandas/tests/indexes/interval/test_interval.py\n@@ -17,9 +17,9 @@\n notna,\n timedelta_range,\n )\n+from pandas._core.api import Float64Index\n+import pandas._core.common as com\n import pandas._testing as tm\n-from pandas.core.api import Float64Index\n-import pandas.core.common as com\n \n \n @pytest.fixture(scope=\"class\", params=[None, \"foo\"])\ndiff --git a/pandas/tests/indexes/interval/test_interval_range.py b/pandas/tests/indexes/interval/test_interval_range.py\nindex 255470cf4683e..dfc4ab3acd2e7 100644\n--- a/pandas/tests/indexes/interval/test_interval_range.py\n+++ b/pandas/tests/indexes/interval/test_interval_range.py\n@@ -3,7 +3,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import is_integer\n+from pandas._core.dtypes.common import is_integer\n \n from pandas import (\n DateOffset,\ndiff --git a/pandas/tests/indexes/multi/test_analytics.py b/pandas/tests/indexes/multi/test_analytics.py\nindex 629cd7eac29b0..71a1f899499d9 100644\n--- a/pandas/tests/indexes/multi/test_analytics.py\n+++ b/pandas/tests/indexes/multi/test_analytics.py\n@@ -8,8 +8,8 @@\n date_range,\n period_range,\n )\n+from pandas._core.api import UInt64Index\n import pandas._testing as tm\n-from pandas.core.api import UInt64Index\n \n \n def test_shift(idx):\ndiff --git a/pandas/tests/indexes/multi/test_astype.py b/pandas/tests/indexes/multi/test_astype.py\nindex 29908537fbe59..0113692a02d99 100644\n--- a/pandas/tests/indexes/multi/test_astype.py\n+++ b/pandas/tests/indexes/multi/test_astype.py\n@@ -1,7 +1,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.dtypes import CategoricalDtype\n+from pandas._core.dtypes.dtypes import CategoricalDtype\n \n import pandas._testing as tm\n \ndiff --git a/pandas/tests/indexes/multi/test_constructors.py b/pandas/tests/indexes/multi/test_constructors.py\nindex 7fad59fc6654c..289c30d82b898 100644\n--- a/pandas/tests/indexes/multi/test_constructors.py\n+++ b/pandas/tests/indexes/multi/test_constructors.py\n@@ -7,7 +7,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike\n+from pandas._core.dtypes.cast import construct_1d_object_array_from_listlike\n \n import pandas as pd\n from pandas import (\ndiff --git a/pandas/tests/indexes/multi/test_get_set.py b/pandas/tests/indexes/multi/test_get_set.py\nindex aa0e91cecd4fc..3090a2574d51f 100644\n--- a/pandas/tests/indexes/multi/test_get_set.py\n+++ b/pandas/tests/indexes/multi/test_get_set.py\n@@ -1,7 +1,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.dtypes import DatetimeTZDtype\n+from pandas._core.dtypes.dtypes import DatetimeTZDtype\n \n import pandas as pd\n from pandas import (\ndiff --git a/pandas/tests/indexes/multi/test_integrity.py b/pandas/tests/indexes/multi/test_integrity.py\nindex c35871745938b..d1893bd452214 100644\n--- a/pandas/tests/indexes/multi/test_integrity.py\n+++ b/pandas/tests/indexes/multi/test_integrity.py\n@@ -3,7 +3,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike\n+from pandas._core.dtypes.cast import construct_1d_object_array_from_listlike\n \n import pandas as pd\n from pandas import (\n@@ -11,8 +11,8 @@\n MultiIndex,\n RangeIndex,\n )\n+from pandas._core.api import Int64Index\n import pandas._testing as tm\n-from pandas.core.api import Int64Index\n \n \n def test_labels_dtypes():\ndiff --git a/pandas/tests/indexes/multi/test_names.py b/pandas/tests/indexes/multi/test_names.py\nindex cfbc90d1b36bb..af10e438e0f40 100644\n--- a/pandas/tests/indexes/multi/test_names.py\n+++ b/pandas/tests/indexes/multi/test_names.py\n@@ -148,7 +148,7 @@ def test_setting_names_from_levels_raises():\n new.index.name = \"bar\"\n \n assert pd.Index._no_setting_name is False\n- assert pd.core.api.NumericIndex._no_setting_name is False\n+ assert pd._core.api.NumericIndex._no_setting_name is False\n assert pd.RangeIndex._no_setting_name is False\n \n \ndiff --git a/pandas/tests/indexes/multi/test_sorting.py b/pandas/tests/indexes/multi/test_sorting.py\nindex 6fd1781beeda4..1c9ba75db5af8 100644\n--- a/pandas/tests/indexes/multi/test_sorting.py\n+++ b/pandas/tests/indexes/multi/test_sorting.py\n@@ -15,8 +15,8 @@\n MultiIndex,\n RangeIndex,\n )\n+from pandas._core.indexes.frozen import FrozenList\n import pandas._testing as tm\n-from pandas.core.indexes.frozen import FrozenList\n \n \n def test_sortlevel(idx):\n@@ -84,7 +84,7 @@ def test_numpy_argsort(idx):\n # pandas compatibility input validation - the\n # rest already perform separate (or no) such\n # validation via their 'values' attribute as\n- # defined in pandas.core.indexes/base.py - they\n+ # defined in pandas._core.indexes/base.py - they\n # cannot be changed at the moment due to\n # backwards compatibility concerns\n if isinstance(type(idx), (CategoricalIndex, RangeIndex)):\ndiff --git a/pandas/tests/indexes/numeric/test_astype.py b/pandas/tests/indexes/numeric/test_astype.py\nindex ee75f56eac7ce..ca273c586fbf3 100644\n--- a/pandas/tests/indexes/numeric/test_astype.py\n+++ b/pandas/tests/indexes/numeric/test_astype.py\n@@ -3,15 +3,15 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import pandas_dtype\n+from pandas._core.dtypes.common import pandas_dtype\n \n from pandas import Index\n-import pandas._testing as tm\n-from pandas.core.indexes.api import (\n+from pandas._core.indexes.api import (\n Float64Index,\n Int64Index,\n UInt64Index,\n )\n+import pandas._testing as tm\n \n \n class TestAstype:\ndiff --git a/pandas/tests/indexes/numeric/test_indexing.py b/pandas/tests/indexes/numeric/test_indexing.py\nindex 1c4cbd21a988e..50be430a38efc 100644\n--- a/pandas/tests/indexes/numeric/test_indexing.py\n+++ b/pandas/tests/indexes/numeric/test_indexing.py\n@@ -9,12 +9,12 @@\n Series,\n Timestamp,\n )\n-import pandas._testing as tm\n-from pandas.core.indexes.api import (\n+from pandas._core.indexes.api import (\n Float64Index,\n Int64Index,\n UInt64Index,\n )\n+import pandas._testing as tm\n \n \n @pytest.fixture\ndiff --git a/pandas/tests/indexes/numeric/test_join.py b/pandas/tests/indexes/numeric/test_join.py\nindex 9bbe7a64ada87..85ce7c8c22738 100644\n--- a/pandas/tests/indexes/numeric/test_join.py\n+++ b/pandas/tests/indexes/numeric/test_join.py\n@@ -1,12 +1,12 @@\n import numpy as np\n import pytest\n \n-import pandas._testing as tm\n-from pandas.core.indexes.api import (\n+from pandas._core.indexes.api import (\n Index,\n Int64Index,\n UInt64Index,\n )\n+import pandas._testing as tm\n \n \n class TestJoinInt64Index:\ndiff --git a/pandas/tests/indexes/numeric/test_numeric.py b/pandas/tests/indexes/numeric/test_numeric.py\nindex 7d2bcdf20c795..f722d7b3500e4 100644\n--- a/pandas/tests/indexes/numeric/test_numeric.py\n+++ b/pandas/tests/indexes/numeric/test_numeric.py\n@@ -8,13 +8,13 @@\n Index,\n Series,\n )\n-import pandas._testing as tm\n-from pandas.core.indexes.api import (\n+from pandas._core.indexes.api import (\n Float64Index,\n Int64Index,\n NumericIndex,\n UInt64Index,\n )\n+import pandas._testing as tm\n from pandas.tests.indexes.common import NumericBase\n \n \ndiff --git a/pandas/tests/indexes/numeric/test_setops.py b/pandas/tests/indexes/numeric/test_setops.py\nindex 9f2174c2de51e..2d1faddd99405 100644\n--- a/pandas/tests/indexes/numeric/test_setops.py\n+++ b/pandas/tests/indexes/numeric/test_setops.py\n@@ -6,14 +6,14 @@\n import numpy as np\n import pytest\n \n-import pandas._testing as tm\n-from pandas.core.indexes.api import (\n+from pandas._core.indexes.api import (\n Float64Index,\n Index,\n Int64Index,\n RangeIndex,\n UInt64Index,\n )\n+import pandas._testing as tm\n \n \n @pytest.fixture\ndiff --git a/pandas/tests/indexes/period/methods/test_astype.py b/pandas/tests/indexes/period/methods/test_astype.py\nindex fbc1d3702115e..2c7c15b4f34ce 100644\n--- a/pandas/tests/indexes/period/methods/test_astype.py\n+++ b/pandas/tests/indexes/period/methods/test_astype.py\n@@ -11,11 +11,11 @@\n Timedelta,\n period_range,\n )\n-import pandas._testing as tm\n-from pandas.core.indexes.api import (\n+from pandas._core.indexes.api import (\n Int64Index,\n UInt64Index,\n )\n+import pandas._testing as tm\n \n \n class TestPeriodIndexAsType:\ndiff --git a/pandas/tests/indexes/period/test_constructors.py b/pandas/tests/indexes/period/test_constructors.py\nindex 5dff5c2ad9c86..086c46624e017 100644\n--- a/pandas/tests/indexes/period/test_constructors.py\n+++ b/pandas/tests/indexes/period/test_constructors.py\n@@ -3,7 +3,7 @@\n \n from pandas._libs.tslibs.period import IncompatibleFrequency\n \n-from pandas.core.dtypes.dtypes import PeriodDtype\n+from pandas._core.dtypes.dtypes import PeriodDtype\n \n from pandas import (\n Index,\n@@ -15,8 +15,8 @@\n offsets,\n period_range,\n )\n+from pandas._core.arrays import PeriodArray\n import pandas._testing as tm\n-from pandas.core.arrays import PeriodArray\n \n \n class TestPeriodIndex:\ndiff --git a/pandas/tests/indexes/period/test_indexing.py b/pandas/tests/indexes/period/test_indexing.py\nindex df40822337ed0..be3cd75a09e81 100644\n--- a/pandas/tests/indexes/period/test_indexing.py\n+++ b/pandas/tests/indexes/period/test_indexing.py\n@@ -22,11 +22,11 @@\n notna,\n period_range,\n )\n-import pandas._testing as tm\n-from pandas.core.api import (\n+from pandas._core.api import (\n Float64Index,\n Int64Index,\n )\n+import pandas._testing as tm\n \n dti4 = date_range(\"2016-01-01\", periods=4)\n dti = dti4[:-1]\ndiff --git a/pandas/tests/indexes/ranges/test_indexing.py b/pandas/tests/indexes/ranges/test_indexing.py\nindex f8c3eff0ab80a..7607b280028e0 100644\n--- a/pandas/tests/indexes/ranges/test_indexing.py\n+++ b/pandas/tests/indexes/ranges/test_indexing.py\n@@ -2,8 +2,8 @@\n import pytest\n \n from pandas import RangeIndex\n+from pandas._core.api import Int64Index\n import pandas._testing as tm\n-from pandas.core.api import Int64Index\n \n \n class TestGetIndexer:\ndiff --git a/pandas/tests/indexes/ranges/test_join.py b/pandas/tests/indexes/ranges/test_join.py\nindex ed21996de891b..e1b18c9897478 100644\n--- a/pandas/tests/indexes/ranges/test_join.py\n+++ b/pandas/tests/indexes/ranges/test_join.py\n@@ -4,8 +4,8 @@\n Index,\n RangeIndex,\n )\n+from pandas._core.indexes.api import Int64Index\n import pandas._testing as tm\n-from pandas.core.indexes.api import Int64Index\n \n \n class TestJoin:\ndiff --git a/pandas/tests/indexes/ranges/test_range.py b/pandas/tests/indexes/ranges/test_range.py\nindex 1c65c369a7e99..3854583f6a065 100644\n--- a/pandas/tests/indexes/ranges/test_range.py\n+++ b/pandas/tests/indexes/ranges/test_range.py\n@@ -1,16 +1,16 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import ensure_platform_int\n+from pandas._core.dtypes.common import ensure_platform_int\n \n import pandas as pd\n-import pandas._testing as tm\n-from pandas.core.indexes.api import (\n+from pandas._core.indexes.api import (\n Float64Index,\n Index,\n Int64Index,\n RangeIndex,\n )\n+import pandas._testing as tm\n from pandas.tests.indexes.common import NumericBase\n \n # aliases to make some tests easier to read\ndiff --git a/pandas/tests/indexes/ranges/test_setops.py b/pandas/tests/indexes/ranges/test_setops.py\nindex 2942010af2720..0a83a325717b8 100644\n--- a/pandas/tests/indexes/ranges/test_setops.py\n+++ b/pandas/tests/indexes/ranges/test_setops.py\n@@ -11,13 +11,13 @@\n import numpy as np\n import pytest\n \n-import pandas._testing as tm\n-from pandas.core.indexes.api import (\n+from pandas._core.indexes.api import (\n Index,\n Int64Index,\n RangeIndex,\n UInt64Index,\n )\n+import pandas._testing as tm\n \n \n class TestRangeIndexSetOps:\ndiff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py\nindex 5d7fc23feb5a8..4727810545e9d 100644\n--- a/pandas/tests/indexes/test_base.py\n+++ b/pandas/tests/indexes/test_base.py\n@@ -25,20 +25,20 @@\n date_range,\n period_range,\n )\n-import pandas._testing as tm\n-from pandas.core.api import (\n+from pandas._core.api import (\n Float64Index,\n Int64Index,\n NumericIndex,\n UInt64Index,\n )\n-from pandas.core.indexes.api import (\n+from pandas._core.indexes.api import (\n Index,\n MultiIndex,\n _get_combined_index,\n ensure_index,\n ensure_index_from_sequences,\n )\n+import pandas._testing as tm\n from pandas.tests.indexes.common import Base\n \n \ndiff --git a/pandas/tests/indexes/test_common.py b/pandas/tests/indexes/test_common.py\nindex d582a469eaf0e..1bc9c49ca9f6d 100644\n--- a/pandas/tests/indexes/test_common.py\n+++ b/pandas/tests/indexes/test_common.py\n@@ -13,7 +13,7 @@\n pa_version_under2p0,\n )\n \n-from pandas.core.dtypes.common import is_integer_dtype\n+from pandas._core.dtypes.common import is_integer_dtype\n \n import pandas as pd\n from pandas import (\n@@ -24,8 +24,8 @@\n RangeIndex,\n TimedeltaIndex,\n )\n+from pandas._core.api import NumericIndex\n import pandas._testing as tm\n-from pandas.core.api import NumericIndex\n \n \n class TestCommon:\ndiff --git a/pandas/tests/indexes/test_frozen.py b/pandas/tests/indexes/test_frozen.py\nindex ace66b5b06a51..7a82a3339bb41 100644\n--- a/pandas/tests/indexes/test_frozen.py\n+++ b/pandas/tests/indexes/test_frozen.py\n@@ -2,7 +2,7 @@\n \n import pytest\n \n-from pandas.core.indexes.frozen import FrozenList\n+from pandas._core.indexes.frozen import FrozenList\n \n \n @pytest.fixture\ndiff --git a/pandas/tests/indexes/test_index_new.py b/pandas/tests/indexes/test_index_new.py\nindex 9a57e3e08a59c..2a6520586a099 100644\n--- a/pandas/tests/indexes/test_index_new.py\n+++ b/pandas/tests/indexes/test_index_new.py\n@@ -10,7 +10,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import is_unsigned_integer_dtype\n+from pandas._core.dtypes.common import is_unsigned_integer_dtype\n \n from pandas import (\n NA,\n@@ -30,12 +30,12 @@\n period_range,\n timedelta_range,\n )\n-import pandas._testing as tm\n-from pandas.core.api import (\n+from pandas._core.api import (\n Float64Index,\n Int64Index,\n UInt64Index,\n )\n+import pandas._testing as tm\n \n \n class TestIndexConstructorInference:\ndiff --git a/pandas/tests/indexes/test_indexing.py b/pandas/tests/indexes/test_indexing.py\nindex 739039241a31d..413275d1231c6 100644\n--- a/pandas/tests/indexes/test_indexing.py\n+++ b/pandas/tests/indexes/test_indexing.py\n@@ -30,12 +30,12 @@\n Series,\n TimedeltaIndex,\n )\n-import pandas._testing as tm\n-from pandas.core.api import (\n+from pandas._core.api import (\n Float64Index,\n Int64Index,\n UInt64Index,\n )\n+import pandas._testing as tm\n \n \n class TestTake:\ndiff --git a/pandas/tests/indexes/test_numpy_compat.py b/pandas/tests/indexes/test_numpy_compat.py\nindex 2704127c7b511..a804fa9424d40 100644\n--- a/pandas/tests/indexes/test_numpy_compat.py\n+++ b/pandas/tests/indexes/test_numpy_compat.py\n@@ -9,13 +9,13 @@\n TimedeltaIndex,\n isna,\n )\n-import pandas._testing as tm\n-from pandas.core.api import (\n+from pandas._core.api import (\n Float64Index,\n NumericIndex,\n )\n-from pandas.core.arrays import BooleanArray\n-from pandas.core.indexes.datetimelike import DatetimeIndexOpsMixin\n+from pandas._core.arrays import BooleanArray\n+from pandas._core.indexes.datetimelike import DatetimeIndexOpsMixin\n+import pandas._testing as tm\n \n \n def test_numpy_ufuncs_out(index):\ndiff --git a/pandas/tests/indexes/test_setops.py b/pandas/tests/indexes/test_setops.py\nindex f38a6c89e1bcb..621023297f807 100644\n--- a/pandas/tests/indexes/test_setops.py\n+++ b/pandas/tests/indexes/test_setops.py\n@@ -8,7 +8,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.cast import find_common_type\n+from pandas._core.dtypes.cast import find_common_type\n \n from pandas import (\n CategoricalIndex,\n@@ -20,17 +20,17 @@\n TimedeltaIndex,\n Timestamp,\n )\n+from pandas._core.api import (\n+ Float64Index,\n+ Int64Index,\n+ UInt64Index,\n+)\n import pandas._testing as tm\n from pandas.api.types import (\n is_datetime64tz_dtype,\n is_signed_integer_dtype,\n pandas_dtype,\n )\n-from pandas.core.api import (\n- Float64Index,\n- Int64Index,\n- UInt64Index,\n-)\n \n \n def test_union_same_types(index):\ndiff --git a/pandas/tests/indexes/timedeltas/methods/test_astype.py b/pandas/tests/indexes/timedeltas/methods/test_astype.py\nindex aa2f7b7af8d98..4eb4ad4e03128 100644\n--- a/pandas/tests/indexes/timedeltas/methods/test_astype.py\n+++ b/pandas/tests/indexes/timedeltas/methods/test_astype.py\n@@ -11,12 +11,12 @@\n TimedeltaIndex,\n timedelta_range,\n )\n-import pandas._testing as tm\n-from pandas.core.api import (\n+from pandas._core.api import (\n Float64Index,\n Int64Index,\n UInt64Index,\n )\n+import pandas._testing as tm\n \n \n class TestTimedeltaIndex:\ndiff --git a/pandas/tests/indexes/timedeltas/test_constructors.py b/pandas/tests/indexes/timedeltas/test_constructors.py\nindex 2a5b1be7bddbd..46dc2be14e3c0 100644\n--- a/pandas/tests/indexes/timedeltas/test_constructors.py\n+++ b/pandas/tests/indexes/timedeltas/test_constructors.py\n@@ -10,11 +10,11 @@\n timedelta_range,\n to_timedelta,\n )\n-import pandas._testing as tm\n-from pandas.core.arrays.timedeltas import (\n+from pandas._core.arrays.timedeltas import (\n TimedeltaArray,\n sequence_to_td64ns,\n )\n+import pandas._testing as tm\n \n \n class TestTimedeltaIndex:\ndiff --git a/pandas/tests/indexes/timedeltas/test_setops.py b/pandas/tests/indexes/timedeltas/test_setops.py\nindex 4574c15343391..3c0044448e9da 100644\n--- a/pandas/tests/indexes/timedeltas/test_setops.py\n+++ b/pandas/tests/indexes/timedeltas/test_setops.py\n@@ -6,8 +6,8 @@\n TimedeltaIndex,\n timedelta_range,\n )\n+from pandas._core.api import Int64Index\n import pandas._testing as tm\n-from pandas.core.api import Int64Index\n \n from pandas.tseries.offsets import Hour\n \ndiff --git a/pandas/tests/indexes/timedeltas/test_timedelta.py b/pandas/tests/indexes/timedeltas/test_timedelta.py\nindex 6904a847b04ed..98004bbcde042 100644\n--- a/pandas/tests/indexes/timedeltas/test_timedelta.py\n+++ b/pandas/tests/indexes/timedeltas/test_timedelta.py\n@@ -12,8 +12,8 @@\n TimedeltaIndex,\n timedelta_range,\n )\n+from pandas._core.indexes.api import Int64Index\n import pandas._testing as tm\n-from pandas.core.indexes.api import Int64Index\n from pandas.tests.indexes.datetimelike import DatetimeLike\n \n randn = np.random.randn\ndiff --git a/pandas/tests/indexing/common.py b/pandas/tests/indexing/common.py\nindex ea9f2584196d3..7d1bb689eb35b 100644\n--- a/pandas/tests/indexing/common.py\n+++ b/pandas/tests/indexing/common.py\n@@ -9,11 +9,11 @@\n Series,\n date_range,\n )\n-import pandas._testing as tm\n-from pandas.core.api import (\n+from pandas._core.api import (\n Float64Index,\n UInt64Index,\n )\n+import pandas._testing as tm\n \n \n def _mklbl(prefix, n):\ndiff --git a/pandas/tests/indexing/multiindex/test_getitem.py b/pandas/tests/indexing/multiindex/test_getitem.py\nindex 3790a6e9a5319..9c8b41427d22c 100644\n--- a/pandas/tests/indexing/multiindex/test_getitem.py\n+++ b/pandas/tests/indexing/multiindex/test_getitem.py\n@@ -7,8 +7,8 @@\n MultiIndex,\n Series,\n )\n+from pandas._core.indexing import IndexingError\n import pandas._testing as tm\n-from pandas.core.indexing import IndexingError\n \n # ----------------------------------------------------------------------------\n # test indexing of Series with multi-level Index\ndiff --git a/pandas/tests/indexing/multiindex/test_partial.py b/pandas/tests/indexing/multiindex/test_partial.py\nindex a57b363c0a448..f3955c5e5d79e 100644\n--- a/pandas/tests/indexing/multiindex/test_partial.py\n+++ b/pandas/tests/indexing/multiindex/test_partial.py\n@@ -9,11 +9,11 @@\n date_range,\n to_datetime,\n )\n-import pandas._testing as tm\n-from pandas.core.api import (\n+from pandas._core.api import (\n Float64Index,\n Int64Index,\n )\n+import pandas._testing as tm\n \n \n class TestMultiIndexPartial:\ndiff --git a/pandas/tests/indexing/test_categorical.py b/pandas/tests/indexing/test_categorical.py\nindex 21a14ef8523f1..c9105961a7866 100644\n--- a/pandas/tests/indexing/test_categorical.py\n+++ b/pandas/tests/indexing/test_categorical.py\n@@ -3,7 +3,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import is_categorical_dtype\n+from pandas._core.dtypes.common import is_categorical_dtype\n \n import pandas as pd\n from pandas import (\ndiff --git a/pandas/tests/indexing/test_coercion.py b/pandas/tests/indexing/test_coercion.py\nindex be8fcfb4d8348..490a751c929d4 100644\n--- a/pandas/tests/indexing/test_coercion.py\n+++ b/pandas/tests/indexing/test_coercion.py\n@@ -15,11 +15,11 @@\n )\n \n import pandas as pd\n-import pandas._testing as tm\n-from pandas.core.api import (\n+from pandas._core.api import (\n Float64Index,\n Int64Index,\n )\n+import pandas._testing as tm\n \n ###############################################################\n # Index / Series common tests which may trigger dtype coercions\ndiff --git a/pandas/tests/indexing/test_floats.py b/pandas/tests/indexing/test_floats.py\nindex 186cba62c138f..6ac3803685788 100644\n--- a/pandas/tests/indexing/test_floats.py\n+++ b/pandas/tests/indexing/test_floats.py\n@@ -7,11 +7,11 @@\n RangeIndex,\n Series,\n )\n-import pandas._testing as tm\n-from pandas.core.api import (\n+from pandas._core.api import (\n Float64Index,\n Int64Index,\n )\n+import pandas._testing as tm\n \n \n def gen_obj(klass, index):\ndiff --git a/pandas/tests/indexing/test_indexers.py b/pandas/tests/indexing/test_indexers.py\nindex ddc5c039160d5..94586233630cf 100644\n--- a/pandas/tests/indexing/test_indexers.py\n+++ b/pandas/tests/indexing/test_indexers.py\n@@ -1,8 +1,8 @@\n-# Tests aimed at pandas.core.indexers\n+# Tests aimed at pandas._core.indexers\n import numpy as np\n import pytest\n \n-from pandas.core.indexers import (\n+from pandas._core.indexers import (\n is_scalar_indexer,\n length_of_indexer,\n validate_indices,\ndiff --git a/pandas/tests/indexing/test_indexing.py b/pandas/tests/indexing/test_indexing.py\nindex 9d10e487e0cc2..be8850fe093a1 100644\n--- a/pandas/tests/indexing/test_indexing.py\n+++ b/pandas/tests/indexing/test_indexing.py\n@@ -9,7 +9,7 @@\n \n from pandas.errors import IndexingError\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_float_dtype,\n is_integer_dtype,\n )\n@@ -24,8 +24,8 @@\n offsets,\n timedelta_range,\n )\n+from pandas._core.api import Float64Index\n import pandas._testing as tm\n-from pandas.core.api import Float64Index\n from pandas.tests.indexing.common import _mklbl\n from pandas.tests.indexing.test_floats import gen_obj\n \ndiff --git a/pandas/tests/indexing/test_loc.py b/pandas/tests/indexing/test_loc.py\nindex 4c38a2219372d..18b52f6a841a5 100644\n--- a/pandas/tests/indexing/test_loc.py\n+++ b/pandas/tests/indexing/test_loc.py\n@@ -35,10 +35,10 @@\n to_datetime,\n to_timedelta,\n )\n+from pandas._core.api import Float64Index\n+from pandas._core.indexing import _one_ellipsis_message\n import pandas._testing as tm\n from pandas.api.types import is_scalar\n-from pandas.core.api import Float64Index\n-from pandas.core.indexing import _one_ellipsis_message\n from pandas.tests.indexing.common import Base\n \n \ndiff --git a/pandas/tests/internals/test_api.py b/pandas/tests/internals/test_api.py\nindex c759cc163106d..8b6ee21441a77 100644\n--- a/pandas/tests/internals/test_api.py\n+++ b/pandas/tests/internals/test_api.py\n@@ -4,8 +4,8 @@\n \"\"\"\n \n import pandas as pd\n-from pandas.core import internals\n-from pandas.core.internals import api\n+from pandas._core import internals\n+from pandas._core.internals import api\n \n \n def test_internals_api():\ndiff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py\nindex 2f3b569c899e1..fcc513b1cc40e 100644\n--- a/pandas/tests/internals/test_internals.py\n+++ b/pandas/tests/internals/test_internals.py\n@@ -11,7 +11,7 @@\n from pandas._libs.internals import BlockPlacement\n import pandas.util._test_decorators as td\n \n-from pandas.core.dtypes.common import is_scalar\n+from pandas._core.dtypes.common import is_scalar\n \n import pandas as pd\n from pandas import (\n@@ -25,22 +25,22 @@\n Timestamp,\n period_range,\n )\n-import pandas._testing as tm\n-import pandas.core.algorithms as algos\n-from pandas.core.arrays import (\n+import pandas._core.algorithms as algos\n+from pandas._core.arrays import (\n DatetimeArray,\n SparseArray,\n TimedeltaArray,\n )\n-from pandas.core.internals import (\n+from pandas._core.internals import (\n BlockManager,\n SingleBlockManager,\n make_block,\n )\n-from pandas.core.internals.blocks import (\n+from pandas._core.internals.blocks import (\n ensure_block_shape,\n new_block,\n )\n+import pandas._testing as tm\n \n # this file contains BlockManager specific tests\n # TODO(ArrayManager) factor out interleave_dtype tests\ndiff --git a/pandas/tests/internals/test_managers.py b/pandas/tests/internals/test_managers.py\nindex 045c3cbb18ba6..aa9598e02ab83 100644\n--- a/pandas/tests/internals/test_managers.py\n+++ b/pandas/tests/internals/test_managers.py\n@@ -1,16 +1,16 @@\n \"\"\"\n Testing interaction between the different managers (BlockManager, ArrayManager)\n \"\"\"\n-from pandas.core.dtypes.missing import array_equivalent\n+from pandas._core.dtypes.missing import array_equivalent\n \n import pandas as pd\n-import pandas._testing as tm\n-from pandas.core.internals import (\n+from pandas._core.internals import (\n ArrayManager,\n BlockManager,\n SingleArrayManager,\n SingleBlockManager,\n )\n+import pandas._testing as tm\n \n \n def test_dataframe_creation():\ndiff --git a/pandas/tests/io/formats/test_info.py b/pandas/tests/io/formats/test_info.py\nindex 54b5e699cd034..a8a0135876c53 100644\n--- a/pandas/tests/io/formats/test_info.py\n+++ b/pandas/tests/io/formats/test_info.py\n@@ -36,7 +36,7 @@ def test_info_empty():\n result = buf.getvalue()\n expected = textwrap.dedent(\n \"\"\"\\\n- <class 'pandas.core.frame.DataFrame'>\n+ <class 'pandas._core.frame.DataFrame'>\n Index: 0 entries\n Empty DataFrame\\n\"\"\"\n )\n@@ -188,7 +188,7 @@ def test_info_memory():\n bytes = float(df.memory_usage().sum())\n expected = textwrap.dedent(\n f\"\"\"\\\n- <class 'pandas.core.frame.DataFrame'>\n+ <class 'pandas._core.frame.DataFrame'>\n RangeIndex: 2 entries, 0 to 1\n Data columns (total 1 columns):\n # Column Non-Null Count Dtype\n@@ -479,7 +479,7 @@ def test_info_int_columns():\n result = buf.getvalue()\n expected = textwrap.dedent(\n \"\"\"\\\n- <class 'pandas.core.frame.DataFrame'>\n+ <class 'pandas._core.frame.DataFrame'>\n Index: 2 entries, A to B\n Data columns (total 2 columns):\n # Column Non-Null Count Dtype\ndiff --git a/pandas/tests/io/formats/test_series_info.py b/pandas/tests/io/formats/test_series_info.py\nindex 761dd07dbef51..787903e6be8a6 100644\n--- a/pandas/tests/io/formats/test_series_info.py\n+++ b/pandas/tests/io/formats/test_series_info.py\n@@ -46,7 +46,7 @@ def test_info_series(lexsorted_two_level_string_multiindex, verbose):\n \n expected = textwrap.dedent(\n \"\"\"\\\n- <class 'pandas.core.series.Series'>\n+ <class 'pandas._core.series.Series'>\n MultiIndex: 10 entries, ('foo', 'one') to ('qux', 'three')\n \"\"\"\n )\n@@ -76,7 +76,7 @@ def test_info_memory():\n memory_bytes = float(s.memory_usage())\n expected = textwrap.dedent(\n f\"\"\"\\\n- <class 'pandas.core.series.Series'>\n+ <class 'pandas._core.series.Series'>\n RangeIndex: 2 entries, 0 to 1\n Series name: None\n Non-Null Count Dtype\ndiff --git a/pandas/tests/io/json/test_json_table_schema.py b/pandas/tests/io/json/test_json_table_schema.py\nindex c90ac2fb3b813..e6b96585d8db6 100644\n--- a/pandas/tests/io/json/test_json_table_schema.py\n+++ b/pandas/tests/io/json/test_json_table_schema.py\n@@ -5,7 +5,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.dtypes import (\n+from pandas._core.dtypes.dtypes import (\n CategoricalDtype,\n DatetimeTZDtype,\n PeriodDtype,\ndiff --git a/pandas/tests/io/json/test_json_table_schema_ext_dtype.py b/pandas/tests/io/json/test_json_table_schema_ext_dtype.py\nindex fbf4006066f6b..aeee9b1b88c5e 100644\n--- a/pandas/tests/io/json/test_json_table_schema_ext_dtype.py\n+++ b/pandas/tests/io/json/test_json_table_schema_ext_dtype.py\n@@ -11,9 +11,9 @@\n DataFrame,\n array,\n )\n-from pandas.core.arrays.integer import Int64Dtype\n-from pandas.core.arrays.string_ import StringDtype\n-from pandas.core.series import Series\n+from pandas._core.arrays.integer import Int64Dtype\n+from pandas._core.arrays.string_ import StringDtype\n+from pandas._core.series import Series\n from pandas.tests.extension.date import (\n DateArray,\n DateDtype,\ndiff --git a/pandas/tests/io/parser/dtypes/test_categorical.py b/pandas/tests/io/parser/dtypes/test_categorical.py\nindex 3b8c520004f12..df8fa38fdcd22 100644\n--- a/pandas/tests/io/parser/dtypes/test_categorical.py\n+++ b/pandas/tests/io/parser/dtypes/test_categorical.py\n@@ -8,7 +8,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.dtypes import CategoricalDtype\n+from pandas._core.dtypes.dtypes import CategoricalDtype\n \n import pandas as pd\n from pandas import (\ndiff --git a/pandas/tests/io/parser/test_parse_dates.py b/pandas/tests/io/parser/test_parse_dates.py\nindex 449d5a954613b..856b073205ed6 100644\n--- a/pandas/tests/io/parser/test_parse_dates.py\n+++ b/pandas/tests/io/parser/test_parse_dates.py\n@@ -32,9 +32,9 @@\n Series,\n Timestamp,\n )\n+from pandas._core.indexes.datetimes import date_range\n import pandas._testing as tm\n from pandas._testing._hypothesis import DATETIME_NO_TZ\n-from pandas.core.indexes.datetimes import date_range\n \n import pandas.io.date_converters as conv\n from pandas.io.parsers import read_csv\ndiff --git a/pandas/tests/io/pytables/test_append.py b/pandas/tests/io/pytables/test_append.py\nindex 40a50c55de2a4..71ad8d0f30743 100644\n--- a/pandas/tests/io/pytables/test_append.py\n+++ b/pandas/tests/io/pytables/test_append.py\n@@ -756,7 +756,7 @@ def test_append_raise(setup_path):\n # series directly\n msg = re.escape(\n \"cannot properly create the storer for: \"\n- \"[group->df,value-><class 'pandas.core.series.Series'>]\"\n+ \"[group->df,value-><class 'pandas._core.series.Series'>]\"\n )\n with pytest.raises(TypeError, match=msg):\n store.append(\"df\", Series(np.arange(10)))\ndiff --git a/pandas/tests/io/pytables/test_put.py b/pandas/tests/io/pytables/test_put.py\nindex d4d95186110f8..4d1520ea0dfeb 100644\n--- a/pandas/tests/io/pytables/test_put.py\n+++ b/pandas/tests/io/pytables/test_put.py\n@@ -21,7 +21,7 @@\n _testing as tm,\n concat,\n )\n-from pandas.core.api import Int64Index\n+from pandas._core.api import Int64Index\n from pandas.tests.io.pytables.common import (\n _maybe_remove,\n ensure_clean_path,\ndiff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py\nindex 5b899079dfffd..18f3516db368e 100644\n--- a/pandas/tests/io/test_parquet.py\n+++ b/pandas/tests/io/test_parquet.py\n@@ -1003,9 +1003,9 @@ def test_read_parquet_manager(self, pa, using_array_manager):\n df.to_parquet(path, pa)\n result = read_parquet(path, pa)\n if using_array_manager:\n- assert isinstance(result._mgr, pd.core.internals.ArrayManager)\n+ assert isinstance(result._mgr, pd._core.internals.ArrayManager)\n else:\n- assert isinstance(result._mgr, pd.core.internals.BlockManager)\n+ assert isinstance(result._mgr, pd._core.internals.BlockManager)\n \n \n class TestParquetFastParquet(Base):\ndiff --git a/pandas/tests/io/test_sql.py b/pandas/tests/io/test_sql.py\nindex e28901fa1a1ed..30e74ca5a3b2d 100644\n--- a/pandas/tests/io/test_sql.py\n+++ b/pandas/tests/io/test_sql.py\n@@ -33,7 +33,7 @@\n \n import pandas.util._test_decorators as td\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_datetime64_dtype,\n is_datetime64tz_dtype,\n )\ndiff --git a/pandas/tests/io/test_stata.py b/pandas/tests/io/test_stata.py\nindex f06bf0035c7dc..aa94d7f8f489d 100644\n--- a/pandas/tests/io/test_stata.py\n+++ b/pandas/tests/io/test_stata.py\n@@ -12,15 +12,15 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import is_categorical_dtype\n+from pandas._core.dtypes.common import is_categorical_dtype\n \n import pandas as pd\n-import pandas._testing as tm\n-from pandas.core.frame import (\n+from pandas._core.frame import (\n DataFrame,\n Series,\n )\n-from pandas.core.indexes.api import ensure_index\n+from pandas._core.indexes.api import ensure_index\n+import pandas._testing as tm\n from pandas.tests.io.test_compression import _compression_to_extension\n \n from pandas.io.parsers import read_csv\ndiff --git a/pandas/tests/libs/test_hashtable.py b/pandas/tests/libs/test_hashtable.py\nindex 0a3a10315b5fd..005c23188f5c9 100644\n--- a/pandas/tests/libs/test_hashtable.py\n+++ b/pandas/tests/libs/test_hashtable.py\n@@ -8,8 +8,8 @@\n from pandas._libs import hashtable as ht\n \n import pandas as pd\n+from pandas._core.algorithms import isin\n import pandas._testing as tm\n-from pandas.core.algorithms import isin\n \n \n @contextmanager\ndiff --git a/pandas/tests/plotting/common.py b/pandas/tests/plotting/common.py\nindex df853770b85f1..3dc671e53081f 100644\n--- a/pandas/tests/plotting/common.py\n+++ b/pandas/tests/plotting/common.py\n@@ -15,7 +15,7 @@\n from pandas.util._decorators import cache_readonly\n import pandas.util._test_decorators as td\n \n-from pandas.core.dtypes.api import is_list_like\n+from pandas._core.dtypes.api import is_list_like\n \n import pandas as pd\n from pandas import Series\ndiff --git a/pandas/tests/plotting/frame/test_frame.py b/pandas/tests/plotting/frame/test_frame.py\nindex 3ec3744e43653..1f7a46d4ada43 100644\n--- a/pandas/tests/plotting/frame/test_frame.py\n+++ b/pandas/tests/plotting/frame/test_frame.py\n@@ -12,7 +12,7 @@\n \n import pandas.util._test_decorators as td\n \n-from pandas.core.dtypes.api import is_list_like\n+from pandas._core.dtypes.api import is_list_like\n \n import pandas as pd\n from pandas import (\ndiff --git a/pandas/tests/plotting/test_datetimelike.py b/pandas/tests/plotting/test_datetimelike.py\nindex cb428daac84ba..49868cf771749 100644\n--- a/pandas/tests/plotting/test_datetimelike.py\n+++ b/pandas/tests/plotting/test_datetimelike.py\n@@ -25,18 +25,18 @@\n isna,\n to_datetime,\n )\n-import pandas._testing as tm\n-from pandas.core.indexes.datetimes import (\n+from pandas._core.indexes.datetimes import (\n DatetimeIndex,\n bdate_range,\n date_range,\n )\n-from pandas.core.indexes.period import (\n+from pandas._core.indexes.period import (\n Period,\n PeriodIndex,\n period_range,\n )\n-from pandas.core.indexes.timedeltas import timedelta_range\n+from pandas._core.indexes.timedeltas import timedelta_range\n+import pandas._testing as tm\n from pandas.tests.plotting.common import TestPlotBase\n \n from pandas.tseries.offsets import WeekOfMonth\ndiff --git a/pandas/tests/reductions/test_reductions.py b/pandas/tests/reductions/test_reductions.py\nindex a68595546eb83..047c2cd4e834d 100644\n--- a/pandas/tests/reductions/test_reductions.py\n+++ b/pandas/tests/reductions/test_reductions.py\n@@ -25,8 +25,8 @@\n timedelta_range,\n to_timedelta,\n )\n+from pandas._core import nanops\n import pandas._testing as tm\n-from pandas.core import nanops\n \n \n def get_objs():\ndiff --git a/pandas/tests/reductions/test_stat_reductions.py b/pandas/tests/reductions/test_stat_reductions.py\nindex 0a6c0ccc891bb..c1419e48da393 100644\n--- a/pandas/tests/reductions/test_stat_reductions.py\n+++ b/pandas/tests/reductions/test_stat_reductions.py\n@@ -13,12 +13,12 @@\n DataFrame,\n Series,\n )\n-import pandas._testing as tm\n-from pandas.core.arrays import (\n+from pandas._core.arrays import (\n DatetimeArray,\n PeriodArray,\n TimedeltaArray,\n )\n+import pandas._testing as tm\n \n \n class TestDatetimeLikeStatReductions:\ndiff --git a/pandas/tests/resample/conftest.py b/pandas/tests/resample/conftest.py\nindex 420c3028382fc..f405fa08306f6 100644\n--- a/pandas/tests/resample/conftest.py\n+++ b/pandas/tests/resample/conftest.py\n@@ -7,8 +7,8 @@\n DataFrame,\n Series,\n )\n-from pandas.core.indexes.datetimes import date_range\n-from pandas.core.indexes.period import period_range\n+from pandas._core.indexes.datetimes import date_range\n+from pandas._core.indexes.period import period_range\n \n # The various methods we support\n downsample_methods = [\ndiff --git a/pandas/tests/resample/test_base.py b/pandas/tests/resample/test_base.py\nindex 1a25749808820..ea96010732bc9 100644\n--- a/pandas/tests/resample/test_base.py\n+++ b/pandas/tests/resample/test_base.py\n@@ -9,13 +9,13 @@\n PeriodIndex,\n Series,\n )\n+from pandas._core.groupby.groupby import DataError\n+from pandas._core.groupby.grouper import Grouper\n+from pandas._core.indexes.datetimes import date_range\n+from pandas._core.indexes.period import period_range\n+from pandas._core.indexes.timedeltas import timedelta_range\n+from pandas._core.resample import _asfreq_compat\n import pandas._testing as tm\n-from pandas.core.groupby.groupby import DataError\n-from pandas.core.groupby.grouper import Grouper\n-from pandas.core.indexes.datetimes import date_range\n-from pandas.core.indexes.period import period_range\n-from pandas.core.indexes.timedeltas import timedelta_range\n-from pandas.core.resample import _asfreq_compat\n \n # a fixture value can be overridden by the test parameter value. Note that the\n # value of the fixture can be overridden this way even if the test doesn't use\ndiff --git a/pandas/tests/resample/test_datetime_index.py b/pandas/tests/resample/test_datetime_index.py\nindex fbc3b385e5098..94ccbf676ea8f 100644\n--- a/pandas/tests/resample/test_datetime_index.py\n+++ b/pandas/tests/resample/test_datetime_index.py\n@@ -20,17 +20,17 @@\n isna,\n notna,\n )\n-import pandas._testing as tm\n-from pandas.core.groupby.grouper import Grouper\n-from pandas.core.indexes.datetimes import date_range\n-from pandas.core.indexes.period import (\n+from pandas._core.groupby.grouper import Grouper\n+from pandas._core.indexes.datetimes import date_range\n+from pandas._core.indexes.period import (\n Period,\n period_range,\n )\n-from pandas.core.resample import (\n+from pandas._core.resample import (\n DatetimeIndex,\n _get_timestamp_range_edges,\n )\n+import pandas._testing as tm\n \n import pandas.tseries.offsets as offsets\n from pandas.tseries.offsets import Minute\ndiff --git a/pandas/tests/resample/test_deprecated.py b/pandas/tests/resample/test_deprecated.py\nindex 126ca05ca1546..79c55c0f6ee2e 100644\n--- a/pandas/tests/resample/test_deprecated.py\n+++ b/pandas/tests/resample/test_deprecated.py\n@@ -11,13 +11,13 @@\n DataFrame,\n Series,\n )\n-import pandas._testing as tm\n-from pandas.core.indexes.datetimes import date_range\n-from pandas.core.indexes.period import (\n+from pandas._core.indexes.datetimes import date_range\n+from pandas._core.indexes.period import (\n PeriodIndex,\n period_range,\n )\n-from pandas.core.indexes.timedeltas import timedelta_range\n+from pandas._core.indexes.timedeltas import timedelta_range\n+import pandas._testing as tm\n \n from pandas.tseries.offsets import (\n BDay,\ndiff --git a/pandas/tests/resample/test_period_index.py b/pandas/tests/resample/test_period_index.py\nindex 4da1f4c589c56..7ccabb31ddee3 100644\n--- a/pandas/tests/resample/test_period_index.py\n+++ b/pandas/tests/resample/test_period_index.py\n@@ -18,14 +18,14 @@\n Series,\n Timestamp,\n )\n-import pandas._testing as tm\n-from pandas.core.indexes.datetimes import date_range\n-from pandas.core.indexes.period import (\n+from pandas._core.indexes.datetimes import date_range\n+from pandas._core.indexes.period import (\n Period,\n PeriodIndex,\n period_range,\n )\n-from pandas.core.resample import _get_period_range_edges\n+from pandas._core.resample import _get_period_range_edges\n+import pandas._testing as tm\n \n import pandas.tseries.offsets as offsets\n \ndiff --git a/pandas/tests/resample/test_resample_api.py b/pandas/tests/resample/test_resample_api.py\nindex 5e10b9ee5277c..09f2555a2b7b5 100644\n--- a/pandas/tests/resample/test_resample_api.py\n+++ b/pandas/tests/resample/test_resample_api.py\n@@ -11,8 +11,8 @@\n NamedAgg,\n Series,\n )\n+from pandas._core.indexes.datetimes import date_range\n import pandas._testing as tm\n-from pandas.core.indexes.datetimes import date_range\n \n dti = date_range(start=datetime(2005, 1, 1), end=datetime(2005, 1, 10), freq=\"Min\")\n \ndiff --git a/pandas/tests/resample/test_resampler_grouper.py b/pandas/tests/resample/test_resampler_grouper.py\nindex c54d9de009940..e60706d391e4c 100644\n--- a/pandas/tests/resample/test_resampler_grouper.py\n+++ b/pandas/tests/resample/test_resampler_grouper.py\n@@ -14,9 +14,9 @@\n TimedeltaIndex,\n Timestamp,\n )\n+from pandas._core.api import Int64Index\n+from pandas._core.indexes.datetimes import date_range\n import pandas._testing as tm\n-from pandas.core.api import Int64Index\n-from pandas.core.indexes.datetimes import date_range\n \n test_frame = DataFrame(\n {\"A\": [1] * 20 + [2] * 12 + [3] * 8, \"B\": np.arange(40)},\ndiff --git a/pandas/tests/resample/test_time_grouper.py b/pandas/tests/resample/test_time_grouper.py\nindex 4498f11d77313..65cf91d45cb87 100644\n--- a/pandas/tests/resample/test_time_grouper.py\n+++ b/pandas/tests/resample/test_time_grouper.py\n@@ -10,9 +10,9 @@\n Series,\n Timestamp,\n )\n+from pandas._core.groupby.grouper import Grouper\n+from pandas._core.indexes.datetimes import date_range\n import pandas._testing as tm\n-from pandas.core.groupby.grouper import Grouper\n-from pandas.core.indexes.datetimes import date_range\n \n test_series = Series(np.random.randn(1000), index=date_range(\"1/1/2000\", periods=1000))\n \ndiff --git a/pandas/tests/resample/test_timedelta.py b/pandas/tests/resample/test_timedelta.py\nindex ad1c361373189..e5d01ad58ecec 100644\n--- a/pandas/tests/resample/test_timedelta.py\n+++ b/pandas/tests/resample/test_timedelta.py\n@@ -8,8 +8,8 @@\n DataFrame,\n Series,\n )\n+from pandas._core.indexes.timedeltas import timedelta_range\n import pandas._testing as tm\n-from pandas.core.indexes.timedeltas import timedelta_range\n \n \n def test_asfreq_bug():\ndiff --git a/pandas/tests/reshape/concat/test_categorical.py b/pandas/tests/reshape/concat/test_categorical.py\nindex 5bafd2e8e8503..48440a4565ab5 100644\n--- a/pandas/tests/reshape/concat/test_categorical.py\n+++ b/pandas/tests/reshape/concat/test_categorical.py\n@@ -1,6 +1,6 @@\n import numpy as np\n \n-from pandas.core.dtypes.dtypes import CategoricalDtype\n+from pandas._core.dtypes.dtypes import CategoricalDtype\n \n import pandas as pd\n from pandas import (\ndiff --git a/pandas/tests/reshape/concat/test_concat.py b/pandas/tests/reshape/concat/test_concat.py\nindex 4ba231523af14..acf6d9a5b7248 100644\n--- a/pandas/tests/reshape/concat/test_concat.py\n+++ b/pandas/tests/reshape/concat/test_concat.py\n@@ -27,9 +27,9 @@\n concat,\n date_range,\n )\n+from pandas._core.arrays import SparseArray\n+from pandas._core.construction import create_series_with_explicit_dtype\n import pandas._testing as tm\n-from pandas.core.arrays import SparseArray\n-from pandas.core.construction import create_series_with_explicit_dtype\n from pandas.tests.extension.decimal import to_decimal\n \n \ndiff --git a/pandas/tests/reshape/concat/test_datetimes.py b/pandas/tests/reshape/concat/test_datetimes.py\nindex 1af54a1d5cf4a..e7ebc2339e89e 100644\n--- a/pandas/tests/reshape/concat/test_datetimes.py\n+++ b/pandas/tests/reshape/concat/test_datetimes.py\n@@ -22,7 +22,7 @@\n \n class TestDatetimeConcat:\n def test_concat_datetime64_block(self):\n- from pandas.core.indexes.datetimes import date_range\n+ from pandas._core.indexes.datetimes import date_range\n \n rng = date_range(\"1/1/2000\", periods=10)\n \ndiff --git a/pandas/tests/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py\nindex 116fb298df61d..d74b1045b1af5 100644\n--- a/pandas/tests/reshape/merge/test_merge.py\n+++ b/pandas/tests/reshape/merge/test_merge.py\n@@ -9,11 +9,11 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_categorical_dtype,\n is_object_dtype,\n )\n-from pandas.core.dtypes.dtypes import CategoricalDtype\n+from pandas._core.dtypes.dtypes import CategoricalDtype\n \n import pandas as pd\n from pandas import (\n@@ -28,18 +28,18 @@\n Series,\n TimedeltaIndex,\n )\n-import pandas._testing as tm\n-from pandas.api.types import CategoricalDtype as CDT\n-from pandas.core.api import (\n+from pandas._core.api import (\n Float64Index,\n Int64Index,\n UInt64Index,\n )\n-from pandas.core.reshape.concat import concat\n-from pandas.core.reshape.merge import (\n+from pandas._core.reshape.concat import concat\n+from pandas._core.reshape.merge import (\n MergeError,\n merge,\n )\n+import pandas._testing as tm\n+from pandas.api.types import CategoricalDtype as CDT\n \n N = 50\n NGROUPS = 8\ndiff --git a/pandas/tests/reshape/merge/test_merge_asof.py b/pandas/tests/reshape/merge/test_merge_asof.py\nindex ebf67b0518c65..1f719fe4cd128 100644\n--- a/pandas/tests/reshape/merge/test_merge_asof.py\n+++ b/pandas/tests/reshape/merge/test_merge_asof.py\n@@ -12,8 +12,8 @@\n read_csv,\n to_datetime,\n )\n+from pandas._core.reshape.merge import MergeError\n import pandas._testing as tm\n-from pandas.core.reshape.merge import MergeError\n \n \n class TestAsOfMerge:\ndiff --git a/pandas/tests/reshape/merge/test_merge_cross.py b/pandas/tests/reshape/merge/test_merge_cross.py\nindex 7e14b515836cf..c2b708044ffc6 100644\n--- a/pandas/tests/reshape/merge/test_merge_cross.py\n+++ b/pandas/tests/reshape/merge/test_merge_cross.py\n@@ -1,11 +1,11 @@\n import pytest\n \n from pandas import DataFrame\n-import pandas._testing as tm\n-from pandas.core.reshape.merge import (\n+from pandas._core.reshape.merge import (\n MergeError,\n merge,\n )\n+import pandas._testing as tm\n \n \n @pytest.mark.parametrize(\ndiff --git a/pandas/tests/reshape/merge/test_multi.py b/pandas/tests/reshape/merge/test_multi.py\nindex 0dbe45eeb1e82..1a22983902321 100644\n--- a/pandas/tests/reshape/merge/test_multi.py\n+++ b/pandas/tests/reshape/merge/test_multi.py\n@@ -9,9 +9,9 @@\n Series,\n Timestamp,\n )\n+from pandas._core.reshape.concat import concat\n+from pandas._core.reshape.merge import merge\n import pandas._testing as tm\n-from pandas.core.reshape.concat import concat\n-from pandas.core.reshape.merge import merge\n \n \n @pytest.fixture\ndiff --git a/pandas/tests/reshape/test_crosstab.py b/pandas/tests/reshape/test_crosstab.py\nindex 76448d5942a5a..16f0a346a2074 100644\n--- a/pandas/tests/reshape/test_crosstab.py\n+++ b/pandas/tests/reshape/test_crosstab.py\n@@ -1,7 +1,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import is_categorical_dtype\n+from pandas._core.dtypes.common import is_categorical_dtype\n \n import pandas as pd\n from pandas import (\ndiff --git a/pandas/tests/reshape/test_cut.py b/pandas/tests/reshape/test_cut.py\nindex 815890f319396..e5e2d7e0c710b 100644\n--- a/pandas/tests/reshape/test_cut.py\n+++ b/pandas/tests/reshape/test_cut.py\n@@ -19,9 +19,9 @@\n timedelta_range,\n to_datetime,\n )\n+import pandas._core.reshape.tile as tmod\n import pandas._testing as tm\n from pandas.api.types import CategoricalDtype as CDT\n-import pandas.core.reshape.tile as tmod\n \n \n def test_simple():\ndiff --git a/pandas/tests/reshape/test_get_dummies.py b/pandas/tests/reshape/test_get_dummies.py\nindex 6c9a60caaa2be..b2458ed58c801 100644\n--- a/pandas/tests/reshape/test_get_dummies.py\n+++ b/pandas/tests/reshape/test_get_dummies.py\n@@ -3,7 +3,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import is_integer_dtype\n+from pandas._core.dtypes.common import is_integer_dtype\n \n import pandas as pd\n from pandas import (\n@@ -13,11 +13,11 @@\n Series,\n get_dummies,\n )\n-import pandas._testing as tm\n-from pandas.core.arrays.sparse import (\n+from pandas._core.arrays.sparse import (\n SparseArray,\n SparseDtype,\n )\n+import pandas._testing as tm\n \n \n class TestGetDummies:\ndiff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py\nindex 8312e3b9de9a7..812b3361272e6 100644\n--- a/pandas/tests/reshape/test_pivot.py\n+++ b/pandas/tests/reshape/test_pivot.py\n@@ -21,10 +21,10 @@\n concat,\n date_range,\n )\n+from pandas._core.reshape import reshape as reshape_lib\n+from pandas._core.reshape.pivot import pivot_table\n import pandas._testing as tm\n from pandas.api.types import CategoricalDtype as CDT\n-from pandas.core.reshape import reshape as reshape_lib\n-from pandas.core.reshape.pivot import pivot_table\n \n \n @pytest.fixture(params=[True, False])\ndiff --git a/pandas/tests/reshape/test_union_categoricals.py b/pandas/tests/reshape/test_union_categoricals.py\nindex 7505d69aee134..f65c860d379d5 100644\n--- a/pandas/tests/reshape/test_union_categoricals.py\n+++ b/pandas/tests/reshape/test_union_categoricals.py\n@@ -1,7 +1,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.concat import union_categoricals\n+from pandas._core.dtypes.concat import union_categoricals\n \n import pandas as pd\n from pandas import (\ndiff --git a/pandas/tests/reshape/test_util.py b/pandas/tests/reshape/test_util.py\nindex 3a9ddaebf2934..79a43a9ac6b89 100644\n--- a/pandas/tests/reshape/test_util.py\n+++ b/pandas/tests/reshape/test_util.py\n@@ -5,8 +5,8 @@\n Index,\n date_range,\n )\n+from pandas._core.reshape.util import cartesian_product\n import pandas._testing as tm\n-from pandas.core.reshape.util import cartesian_product\n \n \n class TestCartesianProduct:\ndiff --git a/pandas/tests/scalar/interval/test_interval.py b/pandas/tests/scalar/interval/test_interval.py\nindex 878b5e6ec0167..cd04eb3c0a1db 100644\n--- a/pandas/tests/scalar/interval/test_interval.py\n+++ b/pandas/tests/scalar/interval/test_interval.py\n@@ -7,8 +7,8 @@\n Timedelta,\n Timestamp,\n )\n+import pandas._core.common as com\n import pandas._testing as tm\n-import pandas.core.common as com\n \n \n @pytest.fixture\ndiff --git a/pandas/tests/scalar/test_na_scalar.py b/pandas/tests/scalar/test_na_scalar.py\nindex 88b06ec578905..070a4e16270f2 100644\n--- a/pandas/tests/scalar/test_na_scalar.py\n+++ b/pandas/tests/scalar/test_na_scalar.py\n@@ -5,7 +5,7 @@\n \n from pandas._libs.missing import NA\n \n-from pandas.core.dtypes.common import is_scalar\n+from pandas._core.dtypes.common import is_scalar\n \n import pandas as pd\n import pandas._testing as tm\ndiff --git a/pandas/tests/scalar/test_nat.py b/pandas/tests/scalar/test_nat.py\nindex 873103b01f64d..7fd4b5cf7ef81 100644\n--- a/pandas/tests/scalar/test_nat.py\n+++ b/pandas/tests/scalar/test_nat.py\n@@ -10,7 +10,7 @@\n \n from pandas._libs.tslibs import iNaT\n \n-from pandas.core.dtypes.common import is_datetime64_any_dtype\n+from pandas._core.dtypes.common import is_datetime64_any_dtype\n \n from pandas import (\n DatetimeIndex,\n@@ -25,13 +25,13 @@\n isna,\n offsets,\n )\n-import pandas._testing as tm\n-from pandas.core.arrays import (\n+from pandas._core.arrays import (\n DatetimeArray,\n PeriodArray,\n TimedeltaArray,\n )\n-from pandas.core.ops import roperator\n+from pandas._core.ops import roperator\n+import pandas._testing as tm\n \n \n @pytest.mark.parametrize(\ndiff --git a/pandas/tests/scalar/timedelta/test_arithmetic.py b/pandas/tests/scalar/timedelta/test_arithmetic.py\nindex f3b84388b0f70..559d16a53a528 100644\n--- a/pandas/tests/scalar/timedelta/test_arithmetic.py\n+++ b/pandas/tests/scalar/timedelta/test_arithmetic.py\n@@ -19,8 +19,8 @@\n Timestamp,\n offsets,\n )\n+from pandas._core import ops\n import pandas._testing as tm\n-from pandas.core import ops\n \n \n class TestTimedeltaAdditionSubtraction:\ndiff --git a/pandas/tests/series/accessors/test_cat_accessor.py b/pandas/tests/series/accessors/test_cat_accessor.py\nindex 53158482fde46..ce9cfb611ca25 100644\n--- a/pandas/tests/series/accessors/test_cat_accessor.py\n+++ b/pandas/tests/series/accessors/test_cat_accessor.py\n@@ -13,9 +13,9 @@\n period_range,\n timedelta_range,\n )\n+from pandas._core.arrays.categorical import CategoricalAccessor\n+from pandas._core.indexes.accessors import Properties\n import pandas._testing as tm\n-from pandas.core.arrays.categorical import CategoricalAccessor\n-from pandas.core.indexes.accessors import Properties\n \n \n class TestCatAccessor:\ndiff --git a/pandas/tests/series/accessors/test_dt_accessor.py b/pandas/tests/series/accessors/test_dt_accessor.py\nindex afb6d0f19daca..718b48bb5399f 100644\n--- a/pandas/tests/series/accessors/test_dt_accessor.py\n+++ b/pandas/tests/series/accessors/test_dt_accessor.py\n@@ -14,7 +14,7 @@\n from pandas._libs.tslibs.timezones import maybe_get_tz\n from pandas.errors import SettingWithCopyError\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_integer_dtype,\n is_list_like,\n )\n@@ -32,12 +32,12 @@\n period_range,\n timedelta_range,\n )\n-import pandas._testing as tm\n-from pandas.core.arrays import (\n+from pandas._core.arrays import (\n DatetimeArray,\n PeriodArray,\n TimedeltaArray,\n )\n+import pandas._testing as tm\n \n ok_for_period = PeriodArray._datetimelike_ops\n ok_for_period_methods = [\"strftime\", \"to_timestamp\", \"asfreq\"]\n@@ -654,7 +654,7 @@ def test_valid_dt_with_missing_values(self):\n \n def test_dt_accessor_api(self):\n # GH 9322\n- from pandas.core.indexes.accessors import (\n+ from pandas._core.indexes.accessors import (\n CombinedDatetimelikeProperties,\n DatetimeProperties,\n )\ndiff --git a/pandas/tests/series/indexing/test_get.py b/pandas/tests/series/indexing/test_get.py\nindex 1a54796dbeec3..8df7d9956b269 100644\n--- a/pandas/tests/series/indexing/test_get.py\n+++ b/pandas/tests/series/indexing/test_get.py\n@@ -3,8 +3,8 @@\n \n import pandas as pd\n from pandas import Series\n+from pandas._core.api import Float64Index\n import pandas._testing as tm\n-from pandas.core.api import Float64Index\n \n \n def test_get():\ndiff --git a/pandas/tests/series/indexing/test_getitem.py b/pandas/tests/series/indexing/test_getitem.py\nindex 111c1652240e2..4668bc90446de 100644\n--- a/pandas/tests/series/indexing/test_getitem.py\n+++ b/pandas/tests/series/indexing/test_getitem.py\n@@ -15,7 +15,7 @@\n timezones,\n )\n \n-from pandas.core.dtypes.common import is_scalar\n+from pandas._core.dtypes.common import is_scalar\n \n import pandas as pd\n from pandas import (\n@@ -29,8 +29,8 @@\n period_range,\n timedelta_range,\n )\n+from pandas._core.indexing import IndexingError\n import pandas._testing as tm\n-from pandas.core.indexing import IndexingError\n \n from pandas.tseries.offsets import BDay\n \ndiff --git a/pandas/tests/series/indexing/test_setitem.py b/pandas/tests/series/indexing/test_setitem.py\nindex abee8e75e89d9..250f301350f89 100644\n--- a/pandas/tests/series/indexing/test_setitem.py\n+++ b/pandas/tests/series/indexing/test_setitem.py\n@@ -8,7 +8,7 @@\n \n from pandas.errors import IndexingError\n \n-from pandas.core.dtypes.common import is_list_like\n+from pandas._core.dtypes.common import is_list_like\n \n from pandas import (\n NA,\ndiff --git a/pandas/tests/series/indexing/test_where.py b/pandas/tests/series/indexing/test_where.py\nindex eabaf23bd36f8..e7daa812b39f2 100644\n--- a/pandas/tests/series/indexing/test_where.py\n+++ b/pandas/tests/series/indexing/test_where.py\n@@ -1,7 +1,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import is_integer\n+from pandas._core.dtypes.common import is_integer\n \n import pandas as pd\n from pandas import (\ndiff --git a/pandas/tests/series/methods/test_astype.py b/pandas/tests/series/methods/test_astype.py\nindex 6bdf93c43c986..856a9249d4abc 100644\n--- a/pandas/tests/series/methods/test_astype.py\n+++ b/pandas/tests/series/methods/test_astype.py\n@@ -512,7 +512,7 @@ def test_astype_categorical_invalid_conversions(self):\n ser = cut(ser, range(0, 10500, 500), right=False, labels=cat)\n \n msg = (\n- \"dtype '<class 'pandas.core.arrays.categorical.Categorical'>' \"\n+ \"dtype '<class 'pandas._core.arrays.categorical.Categorical'>' \"\n \"not understood\"\n )\n with pytest.raises(TypeError, match=msg):\ndiff --git a/pandas/tests/series/methods/test_equals.py b/pandas/tests/series/methods/test_equals.py\nindex 22e27c271df88..e583af44a4add 100644\n--- a/pandas/tests/series/methods/test_equals.py\n+++ b/pandas/tests/series/methods/test_equals.py\n@@ -6,7 +6,7 @@\n \n from pandas._libs.missing import is_matching_na\n \n-from pandas.core.dtypes.common import is_float\n+from pandas._core.dtypes.common import is_float\n \n from pandas import (\n Index,\ndiff --git a/pandas/tests/series/methods/test_is_unique.py b/pandas/tests/series/methods/test_is_unique.py\nindex 960057cb3d646..cbbe851f0b45d 100644\n--- a/pandas/tests/series/methods/test_is_unique.py\n+++ b/pandas/tests/series/methods/test_is_unique.py\n@@ -2,7 +2,7 @@\n import pytest\n \n from pandas import Series\n-from pandas.core.construction import create_series_with_explicit_dtype\n+from pandas._core.construction import create_series_with_explicit_dtype\n \n \n @pytest.mark.parametrize(\ndiff --git a/pandas/tests/series/methods/test_isin.py b/pandas/tests/series/methods/test_isin.py\nindex 2288dfb5c2409..1afe63df40bf0 100644\n--- a/pandas/tests/series/methods/test_isin.py\n+++ b/pandas/tests/series/methods/test_isin.py\n@@ -6,8 +6,8 @@\n Series,\n date_range,\n )\n+from pandas._core.arrays import PeriodArray\n import pandas._testing as tm\n-from pandas.core.arrays import PeriodArray\n \n \n class TestSeriesIsIn:\n@@ -109,7 +109,7 @@ def test_isin_dt64_values_vs_ints(self, dtype):\n res = ser.isin(comps)\n tm.assert_series_equal(res, Series(expected))\n \n- res = pd.core.algorithms.isin(ser, comps)\n+ res = pd._core.algorithms.isin(ser, comps)\n tm.assert_numpy_array_equal(res, expected)\n \n def test_isin_tzawareness_mismatch(self):\n@@ -125,7 +125,7 @@ def test_isin_tzawareness_mismatch(self):\n res = ser.isin(other)\n tm.assert_series_equal(res, Series(expected))\n \n- res = pd.core.algorithms.isin(ser, other)\n+ res = pd._core.algorithms.isin(ser, other)\n tm.assert_numpy_array_equal(res, expected)\n \n def test_isin_period_freq_mismatch(self):\n@@ -145,7 +145,7 @@ def test_isin_period_freq_mismatch(self):\n res = ser.isin(other)\n tm.assert_series_equal(res, Series(expected))\n \n- res = pd.core.algorithms.isin(ser, other)\n+ res = pd._core.algorithms.isin(ser, other)\n tm.assert_numpy_array_equal(res, expected)\n \n @pytest.mark.parametrize(\"values\", [[-9.0, 0.0], [-9, 0]])\ndiff --git a/pandas/tests/series/methods/test_quantile.py b/pandas/tests/series/methods/test_quantile.py\nindex aeff5b3adfe56..088ba2b224062 100644\n--- a/pandas/tests/series/methods/test_quantile.py\n+++ b/pandas/tests/series/methods/test_quantile.py\n@@ -1,15 +1,15 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import is_integer\n+from pandas._core.dtypes.common import is_integer\n \n import pandas as pd\n from pandas import (\n Index,\n Series,\n )\n+from pandas._core.indexes.datetimes import Timestamp\n import pandas._testing as tm\n-from pandas.core.indexes.datetimes import Timestamp\n \n \n class TestSeriesQuantile:\ndiff --git a/pandas/tests/series/methods/test_replace.py b/pandas/tests/series/methods/test_replace.py\nindex 77c9cf4013bd7..f742983fafab3 100644\n--- a/pandas/tests/series/methods/test_replace.py\n+++ b/pandas/tests/series/methods/test_replace.py\n@@ -4,8 +4,8 @@\n import pytest\n \n import pandas as pd\n+from pandas._core.arrays import IntervalArray\n import pandas._testing as tm\n-from pandas.core.arrays import IntervalArray\n \n \n class TestSeriesReplace:\ndiff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py\nindex c8044a44b48ee..c90d8aee83977 100644\n--- a/pandas/tests/series/test_arithmetic.py\n+++ b/pandas/tests/series/test_arithmetic.py\n@@ -7,7 +7,7 @@\n \n from pandas._libs.tslibs import IncompatibleFrequency\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_datetime64_dtype,\n is_datetime64tz_dtype,\n )\n@@ -22,12 +22,12 @@\n date_range,\n isna,\n )\n-import pandas._testing as tm\n-from pandas.core import (\n+from pandas._core import (\n nanops,\n ops,\n )\n-from pandas.core.computation import expressions as expr\n+from pandas._core.computation import expressions as expr\n+import pandas._testing as tm\n \n \n @pytest.fixture(\ndiff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py\nindex 3dce22a06c1b2..0de6e937a2b2c 100644\n--- a/pandas/tests/series/test_constructors.py\n+++ b/pandas/tests/series/test_constructors.py\n@@ -16,11 +16,11 @@\n from pandas.compat.numpy import np_version_under1p20\n import pandas.util._test_decorators as td\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_categorical_dtype,\n is_datetime64tz_dtype,\n )\n-from pandas.core.dtypes.dtypes import CategoricalDtype\n+from pandas._core.dtypes.dtypes import CategoricalDtype\n \n import pandas as pd\n from pandas import (\n@@ -41,13 +41,13 @@\n period_range,\n timedelta_range,\n )\n-import pandas._testing as tm\n-from pandas.core.api import Int64Index\n-from pandas.core.arrays import (\n+from pandas._core.api import Int64Index\n+from pandas._core.arrays import (\n IntervalArray,\n period_array,\n )\n-from pandas.core.internals.blocks import NumericBlock\n+from pandas._core.internals.blocks import NumericBlock\n+import pandas._testing as tm\n \n \n class TestSeriesConstructors:\ndiff --git a/pandas/tests/series/test_logical_ops.py b/pandas/tests/series/test_logical_ops.py\nindex 38e3c5ec8a6f2..9e2eb243c122f 100644\n--- a/pandas/tests/series/test_logical_ops.py\n+++ b/pandas/tests/series/test_logical_ops.py\n@@ -10,8 +10,8 @@\n Series,\n bdate_range,\n )\n+from pandas._core import ops\n import pandas._testing as tm\n-from pandas.core import ops\n \n \n class TestSeriesLogicalOps:\ndiff --git a/pandas/tests/series/test_ufunc.py b/pandas/tests/series/test_ufunc.py\nindex 624496ea26a81..37365298d1672 100644\n--- a/pandas/tests/series/test_ufunc.py\n+++ b/pandas/tests/series/test_ufunc.py\n@@ -4,7 +4,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.dtypes.common import is_dtype_equal\n+from pandas._core.dtypes.common import is_dtype_equal\n \n import pandas as pd\n import pandas._testing as tm\n@@ -283,7 +283,7 @@ def test_multiply(self, values_for_np_reduce, box_with_array, request):\n with tm.assert_produces_warning(warn, match=msg):\n obj = box(values)\n \n- if isinstance(values, pd.core.arrays.SparseArray) and box is not pd.Index:\n+ if isinstance(values, pd._core.arrays.SparseArray) and box is not pd.Index:\n mark = pytest.mark.xfail(reason=\"SparseArray has no 'prod'\")\n request.node.add_marker(mark)\n \ndiff --git a/pandas/tests/strings/conftest.py b/pandas/tests/strings/conftest.py\nindex 15cc5af97a2d6..d15a7b1e70c70 100644\n--- a/pandas/tests/strings/conftest.py\n+++ b/pandas/tests/strings/conftest.py\n@@ -2,7 +2,7 @@\n import pytest\n \n from pandas import Series\n-from pandas.core import strings as strings\n+from pandas._core import strings as strings\n \n _any_string_method = [\n (\"cat\", (), {\"sep\": \",\"}),\ndiff --git a/pandas/tests/strings/test_api.py b/pandas/tests/strings/test_api.py\nindex 974ecc152f17b..eb420a5c5f033 100644\n--- a/pandas/tests/strings/test_api.py\n+++ b/pandas/tests/strings/test_api.py\n@@ -8,7 +8,7 @@\n _testing as tm,\n get_option,\n )\n-from pandas.core import strings as strings\n+from pandas._core import strings as strings\n \n \n def test_api(any_string_dtype):\ndiff --git a/pandas/tests/strings/test_strings.py b/pandas/tests/strings/test_strings.py\nindex aa31a5505b866..526446d7fc7b9 100644\n--- a/pandas/tests/strings/test_strings.py\n+++ b/pandas/tests/strings/test_strings.py\n@@ -743,7 +743,7 @@ def test_normalize_index():\n ],\n )\n def test_index_str_accessor_visibility(values, inferred_type, index_or_series):\n- from pandas.core.strings import StringMethods\n+ from pandas._core.strings import StringMethods\n \n obj = index_or_series(values)\n if index_or_series is Index:\ndiff --git a/pandas/tests/test_aggregation.py b/pandas/tests/test_aggregation.py\nindex 7695c953712ed..d68b6d5f53a40 100644\n--- a/pandas/tests/test_aggregation.py\n+++ b/pandas/tests/test_aggregation.py\n@@ -1,7 +1,7 @@\n import numpy as np\n import pytest\n \n-from pandas.core.apply import (\n+from pandas._core.apply import (\n _make_unique_kwarg_list,\n maybe_mangle_lambdas,\n )\ndiff --git a/pandas/tests/test_algos.py b/pandas/tests/test_algos.py\nindex def63c552e059..050319defbd5e 100644\n--- a/pandas/tests/test_algos.py\n+++ b/pandas/tests/test_algos.py\n@@ -11,14 +11,14 @@\n )\n import pandas.util._test_decorators as td\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_bool_dtype,\n is_complex_dtype,\n is_float_dtype,\n is_integer_dtype,\n is_object_dtype,\n )\n-from pandas.core.dtypes.dtypes import CategoricalDtype as CDT\n+from pandas._core.dtypes.dtypes import CategoricalDtype as CDT\n \n import pandas as pd\n from pandas import (\n@@ -40,10 +40,10 @@\n to_datetime,\n to_timedelta,\n )\n+import pandas._core.algorithms as algos\n+from pandas._core.arrays import DatetimeArray\n+import pandas._core.common as com\n import pandas._testing as tm\n-import pandas.core.algorithms as algos\n-from pandas.core.arrays import DatetimeArray\n-import pandas.core.common as com\n \n \n class TestFactorize:\n@@ -1119,7 +1119,7 @@ def test_isin_unsigned_dtype(self):\n class TestValueCounts:\n def test_value_counts(self):\n np.random.seed(1234)\n- from pandas.core.reshape.tile import cut\n+ from pandas._core.reshape.tile import cut\n \n arr = np.random.randn(4)\n factor = cut(arr, 4)\ndiff --git a/pandas/tests/test_common.py b/pandas/tests/test_common.py\nindex d31f617b9be15..e4e660dd4eee2 100644\n--- a/pandas/tests/test_common.py\n+++ b/pandas/tests/test_common.py\n@@ -7,9 +7,9 @@\n \n import pandas as pd\n from pandas import Series\n+from pandas._core import ops\n+import pandas._core.common as com\n import pandas._testing as tm\n-from pandas.core import ops\n-import pandas.core.common as com\n from pandas.util.version import Version\n \n \ndiff --git a/pandas/tests/test_expressions.py b/pandas/tests/test_expressions.py\nindex a0066ace17bc4..f0d454e7e5fd8 100644\n--- a/pandas/tests/test_expressions.py\n+++ b/pandas/tests/test_expressions.py\n@@ -6,13 +6,13 @@\n import pytest\n \n from pandas import option_context\n-import pandas._testing as tm\n-from pandas.core.api import (\n+from pandas._core.api import (\n DataFrame,\n Index,\n Series,\n )\n-from pandas.core.computation import expressions as expr\n+from pandas._core.computation import expressions as expr\n+import pandas._testing as tm\n \n _frame = DataFrame(np.random.randn(10001, 4), columns=list(\"ABCD\"), dtype=\"float64\")\n _frame2 = DataFrame(np.random.randn(100, 4), columns=list(\"ABCD\"), dtype=\"float64\")\ndiff --git a/pandas/tests/test_nanops.py b/pandas/tests/test_nanops.py\nindex 005f7b088271f..e4470eb286028 100644\n--- a/pandas/tests/test_nanops.py\n+++ b/pandas/tests/test_nanops.py\n@@ -7,16 +7,16 @@\n \n import pandas.util._test_decorators as td\n \n-from pandas.core.dtypes.common import is_integer_dtype\n+from pandas._core.dtypes.common import is_integer_dtype\n \n import pandas as pd\n from pandas import (\n Series,\n isna,\n )\n+from pandas._core.arrays import DatetimeArray\n+import pandas._core.nanops as nanops\n import pandas._testing as tm\n-from pandas.core.arrays import DatetimeArray\n-import pandas.core.nanops as nanops\n \n use_bn = nanops._USE_BOTTLENECK\n \ndiff --git a/pandas/tests/test_register_accessor.py b/pandas/tests/test_register_accessor.py\nindex 3e4e57414269a..eb64798f54f87 100644\n--- a/pandas/tests/test_register_accessor.py\n+++ b/pandas/tests/test_register_accessor.py\n@@ -3,8 +3,8 @@\n import pytest\n \n import pandas as pd\n+from pandas._core import accessor\n import pandas._testing as tm\n-from pandas.core import accessor\n \n \n def test_dirname_mixin():\ndiff --git a/pandas/tests/test_sorting.py b/pandas/tests/test_sorting.py\nindex 396c4d82d01fc..445292d64360e 100644\n--- a/pandas/tests/test_sorting.py\n+++ b/pandas/tests/test_sorting.py\n@@ -18,16 +18,16 @@\n concat,\n merge,\n )\n-import pandas._testing as tm\n-from pandas.core.algorithms import safe_sort\n-import pandas.core.common as com\n-from pandas.core.sorting import (\n+from pandas._core.algorithms import safe_sort\n+import pandas._core.common as com\n+from pandas._core.sorting import (\n _decons_group_index,\n get_group_index,\n is_int64_overflow_possible,\n lexsort_indexer,\n nargsort,\n )\n+import pandas._testing as tm\n \n \n @pytest.fixture\ndiff --git a/pandas/tests/test_take.py b/pandas/tests/test_take.py\nindex f0737f7dc4cce..b69844c05322d 100644\n--- a/pandas/tests/test_take.py\n+++ b/pandas/tests/test_take.py\n@@ -6,8 +6,8 @@\n \n from pandas._libs import iNaT\n \n+import pandas._core.algorithms as algos\n import pandas._testing as tm\n-import pandas.core.algorithms as algos\n \n \n @pytest.fixture(params=[True, False])\ndiff --git a/pandas/tests/tools/test_to_datetime.py b/pandas/tests/tools/test_to_datetime.py\nindex 4c34b0c0aec0a..590cd6a327a25 100644\n--- a/pandas/tests/tools/test_to_datetime.py\n+++ b/pandas/tests/tools/test_to_datetime.py\n@@ -27,7 +27,7 @@\n )\n import pandas.util._test_decorators as td\n \n-from pandas.core.dtypes.common import is_datetime64_ns_dtype\n+from pandas._core.dtypes.common import is_datetime64_ns_dtype\n \n import pandas as pd\n from pandas import (\n@@ -41,10 +41,10 @@\n isna,\n to_datetime,\n )\n+from pandas._core.arrays import DatetimeArray\n+from pandas._core.tools import datetimes as tools\n+from pandas._core.tools.datetimes import start_caching_at\n import pandas._testing as tm\n-from pandas.core.arrays import DatetimeArray\n-from pandas.core.tools import datetimes as tools\n-from pandas.core.tools.datetimes import start_caching_at\n from pandas.util.version import Version\n \n \ndiff --git a/pandas/tests/tools/test_to_time.py b/pandas/tests/tools/test_to_time.py\nindex 7983944d4384d..a2c81037fc777 100644\n--- a/pandas/tests/tools/test_to_time.py\n+++ b/pandas/tests/tools/test_to_time.py\n@@ -5,9 +5,9 @@\n import pytest\n \n from pandas import Series\n+from pandas._core.tools.datetimes import to_time as to_time_alias\n+from pandas._core.tools.times import to_time\n import pandas._testing as tm\n-from pandas.core.tools.datetimes import to_time as to_time_alias\n-from pandas.core.tools.times import to_time\n \n fails_on_non_english = pytest.mark.xfail(\n locale.getlocale()[0] in (\"zh_CN\", \"it_IT\"),\ndiff --git a/pandas/tests/tools/test_to_timedelta.py b/pandas/tests/tools/test_to_timedelta.py\nindex 488e266a1c5c1..7d69d537923e6 100644\n--- a/pandas/tests/tools/test_to_timedelta.py\n+++ b/pandas/tests/tools/test_to_timedelta.py\n@@ -15,8 +15,8 @@\n isna,\n to_timedelta,\n )\n+from pandas._core.arrays import TimedeltaArray\n import pandas._testing as tm\n-from pandas.core.arrays import TimedeltaArray\n \n \n class TestTimedeltas:\ndiff --git a/pandas/tests/tseries/frequencies/test_inference.py b/pandas/tests/tseries/frequencies/test_inference.py\nindex 396cb950bd8b2..de9a06ccbd65e 100644\n--- a/pandas/tests/tseries/frequencies/test_inference.py\n+++ b/pandas/tests/tseries/frequencies/test_inference.py\n@@ -21,12 +21,12 @@\n date_range,\n period_range,\n )\n-import pandas._testing as tm\n-from pandas.core.arrays import (\n+from pandas._core.arrays import (\n DatetimeArray,\n TimedeltaArray,\n )\n-from pandas.core.tools.datetimes import to_datetime\n+from pandas._core.tools.datetimes import to_datetime\n+import pandas._testing as tm\n \n import pandas.tseries.frequencies as frequencies\n import pandas.tseries.offsets as offsets\ndiff --git a/pandas/tests/util/test_assert_attr_equal.py b/pandas/tests/util/test_assert_attr_equal.py\nindex 115ef58e085cc..db3532c2e34a9 100644\n--- a/pandas/tests/util/test_assert_attr_equal.py\n+++ b/pandas/tests/util/test_assert_attr_equal.py\n@@ -2,7 +2,7 @@\n \n import pytest\n \n-from pandas.core.dtypes.common import is_float\n+from pandas._core.dtypes.common import is_float\n \n import pandas._testing as tm\n \ndiff --git a/pandas/tests/util/test_assert_extension_array_equal.py b/pandas/tests/util/test_assert_extension_array_equal.py\nindex dec10e5b76894..3a0aecd4f1b8a 100644\n--- a/pandas/tests/util/test_assert_extension_array_equal.py\n+++ b/pandas/tests/util/test_assert_extension_array_equal.py\n@@ -2,8 +2,8 @@\n import pytest\n \n from pandas import array\n+from pandas._core.arrays.sparse import SparseArray\n import pandas._testing as tm\n-from pandas.core.arrays.sparse import SparseArray\n \n \n @pytest.mark.parametrize(\ndiff --git a/pandas/tests/util/test_assert_series_equal.py b/pandas/tests/util/test_assert_series_equal.py\nindex 2209bed67325c..4659375c8b4c8 100644\n--- a/pandas/tests/util/test_assert_series_equal.py\n+++ b/pandas/tests/util/test_assert_series_equal.py\n@@ -1,6 +1,6 @@\n import pytest\n \n-from pandas.core.dtypes.common import is_extension_array_dtype\n+from pandas._core.dtypes.common import is_extension_array_dtype\n \n import pandas as pd\n from pandas import (\ndiff --git a/pandas/tests/util/test_hashing.py b/pandas/tests/util/test_hashing.py\nindex c2977b81a9b4a..21c3954147782 100644\n--- a/pandas/tests/util/test_hashing.py\n+++ b/pandas/tests/util/test_hashing.py\n@@ -8,8 +8,8 @@\n MultiIndex,\n Series,\n )\n+from pandas._core.util.hashing import hash_tuples\n import pandas._testing as tm\n-from pandas.core.util.hashing import hash_tuples\n from pandas.util import (\n hash_array,\n hash_pandas_object,\ndiff --git a/pandas/tests/util/test_show_versions.py b/pandas/tests/util/test_show_versions.py\nindex 99c7e0a1a8956..fea7745af1722 100644\n--- a/pandas/tests/util/test_show_versions.py\n+++ b/pandas/tests/util/test_show_versions.py\n@@ -22,7 +22,7 @@\n )\n @pytest.mark.filterwarnings(\n # fastparquet\n- \"ignore:pandas.core.index is deprecated:FutureWarning\"\n+ \"ignore:pandas._core.index is deprecated:FutureWarning\"\n )\n @pytest.mark.filterwarnings(\n # pandas_datareader\ndiff --git a/pandas/tests/window/test_base_indexer.py b/pandas/tests/window/test_base_indexer.py\nindex eb5278c2b33ea..0b024e6a6c965 100644\n--- a/pandas/tests/window/test_base_indexer.py\n+++ b/pandas/tests/window/test_base_indexer.py\n@@ -8,16 +8,16 @@\n concat,\n date_range,\n )\n+from pandas._core.indexers.objects import (\n+ ExpandingIndexer,\n+ FixedWindowIndexer,\n+ VariableOffsetWindowIndexer,\n+)\n import pandas._testing as tm\n from pandas.api.indexers import (\n BaseIndexer,\n FixedForwardWindowIndexer,\n )\n-from pandas.core.indexers.objects import (\n- ExpandingIndexer,\n- FixedWindowIndexer,\n- VariableOffsetWindowIndexer,\n-)\n \n from pandas.tseries.offsets import BusinessDay\n \ndiff --git a/pandas/tests/window/test_dtypes.py b/pandas/tests/window/test_dtypes.py\nindex 52011a2d5f760..88e20ac0c1a06 100644\n--- a/pandas/tests/window/test_dtypes.py\n+++ b/pandas/tests/window/test_dtypes.py\n@@ -3,7 +3,7 @@\n \n from pandas.errors import DataError\n \n-from pandas.core.dtypes.common import pandas_dtype\n+from pandas._core.dtypes.common import pandas_dtype\n \n from pandas import (\n NA,\ndiff --git a/pandas/tests/window/test_ewm.py b/pandas/tests/window/test_ewm.py\nindex e0051ee6d51c6..83b7de3156909 100644\n--- a/pandas/tests/window/test_ewm.py\n+++ b/pandas/tests/window/test_ewm.py\n@@ -9,8 +9,8 @@\n Series,\n date_range,\n )\n+from pandas._core.window import ExponentialMovingWindow\n import pandas._testing as tm\n-from pandas.core.window import ExponentialMovingWindow\n \n \n def test_doc_string():\ndiff --git a/pandas/tests/window/test_expanding.py b/pandas/tests/window/test_expanding.py\nindex e0c9294c445f2..5f1b66675346d 100644\n--- a/pandas/tests/window/test_expanding.py\n+++ b/pandas/tests/window/test_expanding.py\n@@ -12,8 +12,8 @@\n isna,\n notna,\n )\n+from pandas._core.window import Expanding\n import pandas._testing as tm\n-from pandas.core.window import Expanding\n \n \n def test_doc_string():\ndiff --git a/pandas/tests/window/test_groupby.py b/pandas/tests/window/test_groupby.py\nindex 5f4805eaa01d2..d5f105c316dea 100644\n--- a/pandas/tests/window/test_groupby.py\n+++ b/pandas/tests/window/test_groupby.py\n@@ -10,9 +10,9 @@\n date_range,\n to_datetime,\n )\n+from pandas._core.groupby.groupby import get_groupby\n import pandas._testing as tm\n from pandas.api.indexers import BaseIndexer\n-from pandas.core.groupby.groupby import get_groupby\n \n \n @pytest.fixture\ndiff --git a/pandas/tests/window/test_pairwise.py b/pandas/tests/window/test_pairwise.py\nindex 6c3f3f7075ce0..73eb79baa30d1 100644\n--- a/pandas/tests/window/test_pairwise.py\n+++ b/pandas/tests/window/test_pairwise.py\n@@ -10,8 +10,8 @@\n Series,\n date_range,\n )\n+from pandas._core.algorithms import safe_sort\n import pandas._testing as tm\n-from pandas.core.algorithms import safe_sort\n \n \n @pytest.fixture(\ndiff --git a/pandas/tests/window/test_rolling.py b/pandas/tests/window/test_rolling.py\nindex 785603f6e05f0..4d190f436cea5 100644\n--- a/pandas/tests/window/test_rolling.py\n+++ b/pandas/tests/window/test_rolling.py\n@@ -24,10 +24,10 @@\n to_datetime,\n to_timedelta,\n )\n+from pandas._core.indexers.objects import VariableOffsetWindowIndexer\n+from pandas._core.window import Rolling\n import pandas._testing as tm\n from pandas.api.indexers import BaseIndexer\n-from pandas.core.indexers.objects import VariableOffsetWindowIndexer\n-from pandas.core.window import Rolling\n \n from pandas.tseries.offsets import BusinessDay\n \ndiff --git a/pandas/tseries/frequencies.py b/pandas/tseries/frequencies.py\nindex c541003f1160c..af7f02488791e 100644\n--- a/pandas/tseries/frequencies.py\n+++ b/pandas/tseries/frequencies.py\n@@ -34,17 +34,17 @@\n from pandas.util._decorators import cache_readonly\n from pandas.util._exceptions import find_stack_level\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_datetime64_dtype,\n is_period_dtype,\n is_timedelta64_dtype,\n )\n-from pandas.core.dtypes.generic import (\n+from pandas._core.dtypes.generic import (\n ABCIndex,\n ABCSeries,\n )\n \n-from pandas.core.algorithms import unique\n+from pandas._core.algorithms import unique\n \n # ---------------------------------------------------------------------\n # Offset names (\"time rules\") and related functions\n@@ -154,7 +154,7 @@ def infer_freq(index, warn: bool = True) -> str | None:\n >>> pd.infer_freq(idx)\n 'D'\n \"\"\"\n- from pandas.core.api import (\n+ from pandas._core.api import (\n DatetimeIndex,\n Float64Index,\n Index,\ndiff --git a/pandas/util/__init__.py b/pandas/util/__init__.py\nindex 7adfca73c2f1e..049e18906d487 100644\n--- a/pandas/util/__init__.py\n+++ b/pandas/util/__init__.py\n@@ -4,7 +4,7 @@\n cache_readonly,\n )\n \n-from pandas.core.util.hashing import ( # noqa:F401\n+from pandas._core.util.hashing import ( # noqa:F401\n hash_array,\n hash_pandas_object,\n )\ndiff --git a/pandas/util/_test_decorators.py b/pandas/util/_test_decorators.py\nindex bbcf984e68b4b..65b4b96a8b09b 100644\n--- a/pandas/util/_test_decorators.py\n+++ b/pandas/util/_test_decorators.py\n@@ -42,7 +42,7 @@ def test_foo():\n )\n from pandas.compat._optional import import_optional_dependency\n \n-from pandas.core.computation.expressions import (\n+from pandas._core.computation.expressions import (\n NUMEXPR_INSTALLED,\n USE_NUMEXPR,\n )\ndiff --git a/pandas/util/_validators.py b/pandas/util/_validators.py\nindex 8e3de9404fbee..a207d0239af7a 100644\n--- a/pandas/util/_validators.py\n+++ b/pandas/util/_validators.py\n@@ -14,7 +14,7 @@\n \n from pandas.util._exceptions import find_stack_level\n \n-from pandas.core.dtypes.common import (\n+from pandas._core.dtypes.common import (\n is_bool,\n is_integer,\n )\n@@ -370,7 +370,7 @@ def validate_fillna_kwargs(value, method, validate_scalar_dict_value=True):\n -------\n value, method : object\n \"\"\"\n- from pandas.core.missing import clean_fill_method\n+ from pandas._core.missing import clean_fill_method\n \n if value is None and method is None:\n raise ValueError(\"Must specify a fill 'value' or 'method'.\")\ndiff --git a/pyproject.toml b/pyproject.toml\nindex 0e2e41fba461c..1d24f6dc581b1 100644\n--- a/pyproject.toml\n+++ b/pyproject.toml\n@@ -143,7 +143,7 @@ ignore_errors = true\n [tool.isort]\n known_pre_libs = \"pandas._config\"\n known_pre_core = [\"pandas._libs\", \"pandas._typing\", \"pandas.util._*\", \"pandas.compat\", \"pandas.errors\"]\n-known_dtypes = \"pandas.core.dtypes\"\n+known_dtypes = \"pandas._core.dtypes\"\n known_post_core = [\"pandas.tseries\", \"pandas.io\", \"pandas.plotting\"]\n sections = [\"FUTURE\", \"STDLIB\", \"THIRDPARTY\" ,\"PRE_LIBS\" , \"PRE_CORE\", \"DTYPES\", \"FIRSTPARTY\", \"POST_CORE\", \"LOCALFOLDER\"]\n profile = \"black\"\ndiff --git a/scripts/tests/test_use_pd_array_in_core.py b/scripts/tests/test_use_pd_array_in_core.py\nindex 8f13a6e735899..df6049d2c3317 100644\n--- a/scripts/tests/test_use_pd_array_in_core.py\n+++ b/scripts/tests/test_use_pd_array_in_core.py\n@@ -5,7 +5,7 @@\n BAD_FILE_0 = \"import pandas as pd\\npd.array\"\n BAD_FILE_1 = \"\\nfrom pandas import array\"\n GOOD_FILE_0 = \"from pandas import array as pd_array\"\n-GOOD_FILE_1 = \"from pandas.core.construction import array as pd_array\"\n+GOOD_FILE_1 = \"from pandas._core.construction import array as pd_array\"\n PATH = \"t.py\"\n \n \n"},"body":{"kind":"string","value":"- [ ] closes #xxxx (Replace xxxx with the Github issue number)\r\n- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature\r\n- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).\r\n- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.\r\n- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.\r\n\r\nWIP, just curious what the CI says."},"url":{"kind":"string","value":"https://api.github.com/repos/pandas-dev/pandas/pulls/47505"},"created_at":{"kind":"string","value":"2022-06-25T16:03:59Z"},"closed_at":{"kind":"string","value":"2022-06-25T16:44:36Z"},"merged_at":{"kind":"null"},"updated_at":{"kind":"string","value":"2022-07-26T20:44:18Z"}}},{"rowIdx":13094,"cells":{"title":{"kind":"string","value":" BUG: read_xml iterparse doesn't handle multiple toplevel elements with lxml parser"},"diff":{"kind":"string","value":"diff --git a/pandas/io/xml.py b/pandas/io/xml.py\nindex 78fbeaad09300..9398e995c81ce 100644\n--- a/pandas/io/xml.py\n+++ b/pandas/io/xml.py\n@@ -693,7 +693,7 @@ def _iterparse_nodes(self) -> list[dict[str, str | None]]:\n row = None\n \n elem.clear()\n- while elem.getprevious() is not None:\n+ while elem.getprevious() is not None and elem.getparent() is not None:\n del elem.getparent()[0]\n \n if dicts == []:\ndiff --git a/pandas/tests/io/xml/test_xml.py b/pandas/tests/io/xml/test_xml.py\nindex eb2230bbf7fd5..b89adf85d8e26 100644\n--- a/pandas/tests/io/xml/test_xml.py\n+++ b/pandas/tests/io/xml/test_xml.py\n@@ -1271,7 +1271,7 @@ def test_wrong_dict_value(datapath, parser):\n read_xml(filename, parser=parser, iterparse={\"book\": \"category\"})\n \n \n-def test_bad_xml(datapath, parser):\n+def test_bad_xml(parser):\n bad_xml = \"\"\"\\\n <?xml version='1.0' encoding='utf-8'?>\n <row>\n@@ -1312,6 +1312,113 @@ def test_bad_xml(datapath, parser):\n )\n \n \n+def test_comment(parser):\n+ xml = \"\"\"\\\n+<!-- comment before root -->\n+<shapes>\n+ <!-- comment within root -->\n+ <shape>\n+ <name>circle</name>\n+ <type>2D</type>\n+ </shape>\n+ <shape>\n+ <name>sphere</name>\n+ <type>3D</type>\n+ <!-- comment within child -->\n+ </shape>\n+ <!-- comment within root -->\n+</shapes>\n+<!-- comment after root -->\"\"\"\n+\n+ df_xpath = read_xml(xml, xpath=\".//shape\", parser=parser)\n+\n+ df_iter = read_xml_iterparse(\n+ xml, parser=parser, iterparse={\"shape\": [\"name\", \"type\"]}\n+ )\n+\n+ df_expected = DataFrame(\n+ {\n+ \"name\": [\"circle\", \"sphere\"],\n+ \"type\": [\"2D\", \"3D\"],\n+ }\n+ )\n+\n+ tm.assert_frame_equal(df_xpath, df_expected)\n+ tm.assert_frame_equal(df_iter, df_expected)\n+\n+\n+def test_dtd(parser):\n+ xml = \"\"\"\\\n+<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n+<!DOCTYPE non-profits [\n+ <!ELEMENT shapes (shape*) >\n+ <!ELEMENT shape ( name, type )>\n+ <!ELEMENT name (#PCDATA)>\n+]>\n+<shapes>\n+ <shape>\n+ <name>circle</name>\n+ <type>2D</type>\n+ </shape>\n+ <shape>\n+ <name>sphere</name>\n+ <type>3D</type>\n+ </shape>\n+</shapes>\"\"\"\n+\n+ df_xpath = read_xml(xml, xpath=\".//shape\", parser=parser)\n+\n+ df_iter = read_xml_iterparse(\n+ xml, parser=parser, iterparse={\"shape\": [\"name\", \"type\"]}\n+ )\n+\n+ df_expected = DataFrame(\n+ {\n+ \"name\": [\"circle\", \"sphere\"],\n+ \"type\": [\"2D\", \"3D\"],\n+ }\n+ )\n+\n+ tm.assert_frame_equal(df_xpath, df_expected)\n+ tm.assert_frame_equal(df_iter, df_expected)\n+\n+\n+def test_processing_instruction(parser):\n+ xml = \"\"\"\\\n+<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n+<?xml-stylesheet type=\"text/xsl\" href=\"style.xsl\"?>\n+<?display table-view?>\n+<?sort alpha-ascending?>\n+<?textinfo whitespace is allowed ?>\n+<?elementnames <shape>, <name>, <type> ?>\n+<shapes>\n+ <shape>\n+ <name>circle</name>\n+ <type>2D</type>\n+ </shape>\n+ <shape>\n+ <name>sphere</name>\n+ <type>3D</type>\n+ </shape>\n+</shapes>\"\"\"\n+\n+ df_xpath = read_xml(xml, xpath=\".//shape\", parser=parser)\n+\n+ df_iter = read_xml_iterparse(\n+ xml, parser=parser, iterparse={\"shape\": [\"name\", \"type\"]}\n+ )\n+\n+ df_expected = DataFrame(\n+ {\n+ \"name\": [\"circle\", \"sphere\"],\n+ \"type\": [\"2D\", \"3D\"],\n+ }\n+ )\n+\n+ tm.assert_frame_equal(df_xpath, df_expected)\n+ tm.assert_frame_equal(df_iter, df_expected)\n+\n+\n def test_no_result(datapath, parser):\n filename = datapath(\"io\", \"data\", \"xml\", \"books.xml\")\n with pytest.raises(\n"},"body":{"kind":"string","value":"- [X] closes #47422\r\n- [X] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature\r\n- [X] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).\r\n- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.\r\n- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature. *(not necessary for unreleased new 1.5 feature)*\r\n"},"url":{"kind":"string","value":"https://api.github.com/repos/pandas-dev/pandas/pulls/47504"},"created_at":{"kind":"string","value":"2022-06-25T03:54:20Z"},"closed_at":{"kind":"string","value":"2022-06-27T22:26:49Z"},"merged_at":{"kind":"string","value":"2022-06-27T22:26:49Z"},"updated_at":{"kind":"string","value":"2022-06-28T22:45:56Z"}}},{"rowIdx":13095,"cells":{"title":{"kind":"string","value":"DOC: Resolve links in whatsnew"},"diff":{"kind":"string","value":"diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst\nindex 7e943bb5832e6..a931838fa4910 100644\n--- a/doc/source/whatsnew/v1.5.0.rst\n+++ b/doc/source/whatsnew/v1.5.0.rst\n@@ -232,7 +232,7 @@ Other enhancements\n ^^^^^^^^^^^^^^^^^^\n - :meth:`Series.map` now raises when ``arg`` is dict but ``na_action`` is not either ``None`` or ``'ignore'`` (:issue:`46588`)\n - :meth:`MultiIndex.to_frame` now supports the argument ``allow_duplicates`` and raises on duplicate labels if it is missing or False (:issue:`45245`)\n-- :class:`StringArray` now accepts array-likes containing nan-likes (``None``, ``np.nan``) for the ``values`` parameter in its constructor in addition to strings and :attr:`pandas.NA`. (:issue:`40839`)\n+- :class:`.StringArray` now accepts array-likes containing nan-likes (``None``, ``np.nan``) for the ``values`` parameter in its constructor in addition to strings and :attr:`pandas.NA`. (:issue:`40839`)\n - Improved the rendering of ``categories`` in :class:`CategoricalIndex` (:issue:`45218`)\n - :meth:`DataFrame.plot` will now allow the ``subplots`` parameter to be a list of iterables specifying column groups, so that columns may be grouped together in the same subplot (:issue:`29688`).\n - :meth:`to_numeric` now preserves float64 arrays when downcasting would generate values not representable in float32 (:issue:`43693`)\n@@ -243,17 +243,17 @@ Other enhancements\n - Implemented a ``bool``-dtype :class:`Index`, passing a bool-dtype array-like to ``pd.Index`` will now retain ``bool`` dtype instead of casting to ``object`` (:issue:`45061`)\n - Implemented a complex-dtype :class:`Index`, passing a complex-dtype array-like to ``pd.Index`` will now retain complex dtype instead of casting to ``object`` (:issue:`45845`)\n - :class:`Series` and :class:`DataFrame` with ``IntegerDtype`` now supports bitwise operations (:issue:`34463`)\n-- Add ``milliseconds`` field support for :class:`~pandas.DateOffset` (:issue:`43371`)\n+- Add ``milliseconds`` field support for :class:`.DateOffset` (:issue:`43371`)\n - :meth:`DataFrame.reset_index` now accepts a ``names`` argument which renames the index names (:issue:`6878`)\n-- :meth:`pd.concat` now raises when ``levels`` is given but ``keys`` is None (:issue:`46653`)\n-- :meth:`pd.concat` now raises when ``levels`` contains duplicate values (:issue:`46653`)\n+- :func:`concat` now raises when ``levels`` is given but ``keys`` is None (:issue:`46653`)\n+- :func:`concat` now raises when ``levels`` contains duplicate values (:issue:`46653`)\n - Added ``numeric_only`` argument to :meth:`DataFrame.corr`, :meth:`DataFrame.corrwith`, :meth:`DataFrame.cov`, :meth:`DataFrame.idxmin`, :meth:`DataFrame.idxmax`, :meth:`.DataFrameGroupBy.idxmin`, :meth:`.DataFrameGroupBy.idxmax`, :meth:`.GroupBy.var`, :meth:`.GroupBy.std`, :meth:`.GroupBy.sem`, and :meth:`.DataFrameGroupBy.quantile` (:issue:`46560`)\n - A :class:`errors.PerformanceWarning` is now thrown when using ``string[pyarrow]`` dtype with methods that don't dispatch to ``pyarrow.compute`` methods (:issue:`42613`, :issue:`46725`)\n - Added ``validate`` argument to :meth:`DataFrame.join` (:issue:`46622`)\n - A :class:`errors.PerformanceWarning` is now thrown when using ``string[pyarrow]`` dtype with methods that don't dispatch to ``pyarrow.compute`` methods (:issue:`42613`)\n - Added ``numeric_only`` argument to :meth:`Resampler.sum`, :meth:`Resampler.prod`, :meth:`Resampler.min`, :meth:`Resampler.max`, :meth:`Resampler.first`, and :meth:`Resampler.last` (:issue:`46442`)\n - ``times`` argument in :class:`.ExponentialMovingWindow` now accepts ``np.timedelta64`` (:issue:`47003`)\n-- :class:`DataError`, :class:`SpecificationError`, :class:`SettingWithCopyError`, :class:`SettingWithCopyWarning`, :class:`NumExprClobberingError`, :class:`UndefinedVariableError`, and :class:`IndexingError` are now exposed in ``pandas.errors`` (:issue:`27656`)\n+- :class:`.DataError`, :class:`.SpecificationError`, :class:`.SettingWithCopyError`, :class:`.SettingWithCopyWarning`, :class:`.NumExprClobberingError`, :class:`.UndefinedVariableError`, and :class:`.IndexingError` are now exposed in ``pandas.errors`` (:issue:`27656`)\n - Added ``check_like`` argument to :func:`testing.assert_series_equal` (:issue:`47247`)\n - Allow reading compressed SAS files with :func:`read_sas` (e.g., ``.sas7bdat.gz`` files)\n \n@@ -702,7 +702,7 @@ Other Deprecations\n - Deprecated treating float-dtype data as wall-times when passed with a timezone to :class:`Series` or :class:`DatetimeIndex` (:issue:`45573`)\n - Deprecated the behavior of :meth:`Series.fillna` and :meth:`DataFrame.fillna` with ``timedelta64[ns]`` dtype and incompatible fill value; in a future version this will cast to a common dtype (usually object) instead of raising, matching the behavior of other dtypes (:issue:`45746`)\n - Deprecated the ``warn`` parameter in :func:`infer_freq` (:issue:`45947`)\n-- Deprecated allowing non-keyword arguments in :meth:`ExtensionArray.argsort` (:issue:`46134`)\n+- Deprecated allowing non-keyword arguments in :meth:`.ExtensionArray.argsort` (:issue:`46134`)\n - Deprecated treating all-bool ``object``-dtype columns as bool-like in :meth:`DataFrame.any` and :meth:`DataFrame.all` with ``bool_only=True``, explicitly cast to bool instead (:issue:`46188`)\n - Deprecated behavior of method :meth:`DataFrame.quantile`, attribute ``numeric_only`` will default False. Including datetime/timedelta columns in the result (:issue:`7308`).\n - Deprecated :attr:`Timedelta.freq` and :attr:`Timedelta.is_populated` (:issue:`46430`)\n@@ -716,8 +716,8 @@ Other Deprecations\n - Deprecated the ``closed`` argument in :class:`Interval` in favor of ``inclusive`` argument; In a future version passing ``closed`` will raise (:issue:`40245`)\n - Deprecated the ``closed`` argument in :class:`IntervalIndex` in favor of ``inclusive`` argument; In a future version passing ``closed`` will raise (:issue:`40245`)\n - Deprecated the ``closed`` argument in :class:`IntervalDtype` in favor of ``inclusive`` argument; In a future version passing ``closed`` will raise (:issue:`40245`)\n-- Deprecated the ``closed`` argument in :class:`IntervalArray` in favor of ``inclusive`` argument; In a future version passing ``closed`` will raise (:issue:`40245`)\n-- Deprecated the ``closed`` argument in :class:`intervaltree` in favor of ``inclusive`` argument; In a future version passing ``closed`` will raise (:issue:`40245`)\n+- Deprecated the ``closed`` argument in :class:`.IntervalArray` in favor of ``inclusive`` argument; In a future version passing ``closed`` will raise (:issue:`40245`)\n+- Deprecated the ``closed`` argument in :class:`IntervalTree` in favor of ``inclusive`` argument; In a future version passing ``closed`` will raise (:issue:`40245`)\n - Deprecated the ``closed`` argument in :class:`ArrowInterval` in favor of ``inclusive`` argument; In a future version passing ``closed`` will raise (:issue:`40245`)\n - Deprecated allowing ``unit=\"M\"`` or ``unit=\"Y\"`` in :class:`Timestamp` constructor with a non-round float value (:issue:`47267`)\n - Deprecated the ``display.column_space`` global configuration option (:issue:`7576`)\n@@ -756,8 +756,8 @@ Bug fixes\n \n Categorical\n ^^^^^^^^^^^\n-- Bug in :meth:`Categorical.view` not accepting integer dtypes (:issue:`25464`)\n-- Bug in :meth:`CategoricalIndex.union` when the index's categories are integer-dtype and the index contains ``NaN`` values incorrectly raising instead of casting to ``float64`` (:issue:`45362`)\n+- Bug in :meth:`.Categorical.view` not accepting integer dtypes (:issue:`25464`)\n+- Bug in :meth:`.CategoricalIndex.union` when the index's categories are integer-dtype and the index contains ``NaN`` values incorrectly raising instead of casting to ``float64`` (:issue:`45362`)\n -\n \n Datetimelike\n@@ -770,7 +770,7 @@ Datetimelike\n - Bug in :meth:`DatetimeIndex.tz_localize` localizing to UTC failing to make a copy of the underlying data (:issue:`46460`)\n - Bug in :meth:`DatetimeIndex.resolution` incorrectly returning \"day\" instead of \"nanosecond\" for nanosecond-resolution indexes (:issue:`46903`)\n - Bug in :class:`Timestamp` with an integer or float value and ``unit=\"Y\"`` or ``unit=\"M\"`` giving slightly-wrong results (:issue:`47266`)\n-- Bug in :class:`DatetimeArray` construction when passed another :class:`DatetimeArray` and ``freq=None`` incorrectly inferring the freq from the given array (:issue:`47296`)\n+- Bug in :class:`.DatetimeArray` construction when passed another :class:`.DatetimeArray` and ``freq=None`` incorrectly inferring the freq from the given array (:issue:`47296`)\n -\n \n Timedelta\n@@ -889,7 +889,7 @@ I/O\n \n Period\n ^^^^^^\n-- Bug in subtraction of :class:`Period` from :class:`PeriodArray` returning wrong results (:issue:`45999`)\n+- Bug in subtraction of :class:`Period` from :class:`.PeriodArray` returning wrong results (:issue:`45999`)\n - Bug in :meth:`Period.strftime` and :meth:`PeriodIndex.strftime`, directives ``%l`` and ``%u`` were giving wrong results (:issue:`46252`)\n - Bug in inferring an incorrect ``freq`` when passing a string to :class:`Period` microseconds that are a multiple of 1000 (:issue:`46811`)\n - Bug in constructing a :class:`Period` from a :class:`Timestamp` or ``np.datetime64`` object with non-zero nanoseconds and ``freq=\"ns\"`` incorrectly truncating the nanoseconds (:issue:`46811`)\n@@ -914,17 +914,17 @@ Groupby/resample/rolling\n - Bug in :meth:`.DataFrameGroupBy.size` and :meth:`.DataFrameGroupBy.transform` with ``func=\"size\"`` produced incorrect results when ``axis=1`` (:issue:`45715`)\n - Bug in :meth:`.ExponentialMovingWindow.mean` with ``axis=1`` and ``engine='numba'`` when the :class:`DataFrame` has more columns than rows (:issue:`46086`)\n - Bug when using ``engine=\"numba\"`` would return the same jitted function when modifying ``engine_kwargs`` (:issue:`46086`)\n-- Bug in :meth:`.DataFrameGroupby.transform` fails when ``axis=1`` and ``func`` is ``\"first\"`` or ``\"last\"`` (:issue:`45986`)\n-- Bug in :meth:`DataFrameGroupby.cumsum` with ``skipna=False`` giving incorrect results (:issue:`46216`)\n+- Bug in :meth:`.DataFrameGroupBy.transform` fails when ``axis=1`` and ``func`` is ``\"first\"`` or ``\"last\"`` (:issue:`45986`)\n+- Bug in :meth:`DataFrameGroupBy.cumsum` with ``skipna=False`` giving incorrect results (:issue:`46216`)\n - Bug in :meth:`.GroupBy.cumsum` with ``timedelta64[ns]`` dtype failing to recognize ``NaT`` as a null value (:issue:`46216`)\n-- Bug in :meth:`GroupBy.cummin` and :meth:`GroupBy.cummax` with nullable dtypes incorrectly altering the original data in place (:issue:`46220`)\n-- Bug in :meth:`GroupBy.cummax` with ``int64`` dtype with leading value being the smallest possible int64 (:issue:`46382`)\n-- Bug in :meth:`GroupBy.max` with empty groups and ``uint64`` dtype incorrectly raising ``RuntimeError`` (:issue:`46408`)\n+- Bug in :meth:`.GroupBy.cummin` and :meth:`.GroupBy.cummax` with nullable dtypes incorrectly altering the original data in place (:issue:`46220`)\n+- Bug in :meth:`.GroupBy.cummax` with ``int64`` dtype with leading value being the smallest possible int64 (:issue:`46382`)\n+- Bug in :meth:`.GroupBy.max` with empty groups and ``uint64`` dtype incorrectly raising ``RuntimeError`` (:issue:`46408`)\n - Bug in :meth:`.GroupBy.apply` would fail when ``func`` was a string and args or kwargs were supplied (:issue:`46479`)\n - Bug in :meth:`SeriesGroupBy.apply` would incorrectly name its result when there was a unique group (:issue:`46369`)\n-- Bug in :meth:`Rolling.sum` and :meth:`Rolling.mean` would give incorrect result with window of same values (:issue:`42064`, :issue:`46431`)\n-- Bug in :meth:`Rolling.var` and :meth:`Rolling.std` would give non-zero result with window of same values (:issue:`42064`)\n-- Bug in :meth:`Rolling.skew` and :meth:`Rolling.kurt` would give NaN with window of same values (:issue:`30993`)\n+- Bug in :meth:`.Rolling.sum` and :meth:`.Rolling.mean` would give incorrect result with window of same values (:issue:`42064`, :issue:`46431`)\n+- Bug in :meth:`.Rolling.var` and :meth:`.Rolling.std` would give non-zero result with window of same values (:issue:`42064`)\n+- Bug in :meth:`.Rolling.skew` and :meth:`.Rolling.kurt` would give NaN with window of same values (:issue:`30993`)\n - Bug in :meth:`.Rolling.var` would segfault calculating weighted variance when window size was larger than data size (:issue:`46760`)\n - Bug in :meth:`Grouper.__repr__` where ``dropna`` was not included. Now it is (:issue:`46754`)\n - Bug in :meth:`DataFrame.rolling` gives ValueError when center=True, axis=1 and win_type is specified (:issue:`46135`)\n@@ -958,8 +958,8 @@ Styler\n ^^^^^^\n - Bug when attempting to apply styling functions to an empty DataFrame subset (:issue:`45313`)\n - Bug in :class:`CSSToExcelConverter` leading to ``TypeError`` when border color provided without border style for ``xlsxwriter`` engine (:issue:`42276`)\n-- Bug in :meth:`Styler.set_sticky` leading to white text on white background in dark mode (:issue:`46984`)\n-- Bug in :meth:`Styler.to_latex` causing ``UnboundLocalError`` when ``clines=\"all;data\"`` and the ``DataFrame`` has no rows. (:issue:`47203`)\n+- Bug in :meth:`.Styler.set_sticky` leading to white text on white background in dark mode (:issue:`46984`)\n+- Bug in :meth:`.Styler.to_latex` causing ``UnboundLocalError`` when ``clines=\"all;data\"`` and the ``DataFrame`` has no rows. (:issue:`47203`)\n \n Metadata\n ^^^^^^^^\n"},"body":{"kind":"string","value":"- [ ] closes #xxxx (Replace xxxx with the Github issue number)\r\n- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature\r\n- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).\r\n- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.\r\n- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.\r\n\r\nOnly added `.` in places where it would get the link to resolve."},"url":{"kind":"string","value":"https://api.github.com/repos/pandas-dev/pandas/pulls/47499"},"created_at":{"kind":"string","value":"2022-06-24T19:24:15Z"},"closed_at":{"kind":"string","value":"2022-06-24T20:57:26Z"},"merged_at":{"kind":"string","value":"2022-06-24T20:57:26Z"},"updated_at":{"kind":"string","value":"2022-06-24T21:31:27Z"}}},{"rowIdx":13096,"cells":{"title":{"kind":"string","value":"DOC: Minor fixes in whatsnew 1.5.0"},"diff":{"kind":"string","value":"diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst\nindex 35594fbc8fb8a..b8d8f318611fc 100644\n--- a/doc/source/whatsnew/v1.5.0.rst\n+++ b/doc/source/whatsnew/v1.5.0.rst\n@@ -477,6 +477,9 @@ Deprecations\n \n .. _whatsnew_150.deprecations.int_slicing_series:\n \n+Label-based integer slicing on a Series with an Int64Index or RangeIndex\n+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n+\n In a future version, integer slicing on a :class:`Series` with a :class:`Int64Index` or :class:`RangeIndex` will be treated as *label-based*, not positional. This will make the behavior consistent with other :meth:`Series.__getitem__` and :meth:`Series.__setitem__` behaviors (:issue:`45162`).\n \n For example:\n@@ -830,7 +833,7 @@ Indexing\n - Bug when setting a value too large for a :class:`Series` dtype failing to coerce to a common type (:issue:`26049`, :issue:`32878`)\n - Bug in :meth:`loc.__setitem__` treating ``range`` keys as positional instead of label-based (:issue:`45479`)\n - Bug in :meth:`Series.__setitem__` when setting ``boolean`` dtype values containing ``NA`` incorrectly raising instead of casting to ``boolean`` dtype (:issue:`45462`)\n-- Bug in :meth:`Series.__setitem__` where setting :attr:`NA` into a numeric-dtpye :class:`Series` would incorrectly upcast to object-dtype rather than treating the value as ``np.nan`` (:issue:`44199`)\n+- Bug in :meth:`Series.__setitem__` where setting :attr:`NA` into a numeric-dtype :class:`Series` would incorrectly upcast to object-dtype rather than treating the value as ``np.nan`` (:issue:`44199`)\n - Bug in :meth:`Series.__setitem__` with ``datetime64[ns]`` dtype, an all-``False`` boolean mask, and an incompatible value incorrectly casting to ``object`` instead of retaining ``datetime64[ns]`` dtype (:issue:`45967`)\n - Bug in :meth:`Index.__getitem__` raising ``ValueError`` when indexer is from boolean dtype with ``NA`` (:issue:`45806`)\n - Bug in :meth:`Series.mask` with ``inplace=True`` or setting values with a boolean mask with small integer dtypes incorrectly raising (:issue:`45750`)\n@@ -936,7 +939,7 @@ Reshaping\n - Bug in :func:`concat` between a :class:`Series` with integer dtype and another with :class:`CategoricalDtype` with integer categories and containing ``NaN`` values casting to object dtype instead of ``float64`` (:issue:`45359`)\n - Bug in :func:`get_dummies` that selected object and categorical dtypes but not string (:issue:`44965`)\n - Bug in :meth:`DataFrame.align` when aligning a :class:`MultiIndex` to a :class:`Series` with another :class:`MultiIndex` (:issue:`46001`)\n-- Bug in concanenation with ``IntegerDtype``, or ``FloatingDtype`` arrays where the resulting dtype did not mirror the behavior of the non-nullable dtypes (:issue:`46379`)\n+- Bug in concatenation with ``IntegerDtype``, or ``FloatingDtype`` arrays where the resulting dtype did not mirror the behavior of the non-nullable dtypes (:issue:`46379`)\n - Bug in :func:`concat` not sorting the column names when ``None`` is included (:issue:`47331`)\n - Bug in :func:`concat` with identical key leads to error when indexing :class:`MultiIndex` (:issue:`46519`)\n - Bug in :meth:`DataFrame.join` with a list when using suffixes to join DataFrames with duplicate column names (:issue:`46396`)\n"},"body":{"kind":"string","value":"- [ ] closes #xxxx (Replace xxxx with the Github issue number)\r\n- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature\r\n- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).\r\n- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.\r\n- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.\r\n\r\n"},"url":{"kind":"string","value":"https://api.github.com/repos/pandas-dev/pandas/pulls/47498"},"created_at":{"kind":"string","value":"2022-06-24T18:21:11Z"},"closed_at":{"kind":"string","value":"2022-06-24T20:55:52Z"},"merged_at":{"kind":"string","value":"2022-06-24T20:55:52Z"},"updated_at":{"kind":"string","value":"2022-06-24T21:30:42Z"}}},{"rowIdx":13097,"cells":{"title":{"kind":"string","value":"(WIP) TYP: add some obvious -> None to pandas/core"},"diff":{"kind":"string","value":"diff --git a/pandas/core/array_algos/replace.py b/pandas/core/array_algos/replace.py\nindex 19a44dbfe6f6d..1192191512e10 100644\n--- a/pandas/core/array_algos/replace.py\n+++ b/pandas/core/array_algos/replace.py\n@@ -67,7 +67,7 @@ def compare_or_regex_search(\n \n def _check_comparison_types(\n result: ArrayLike | bool, a: ArrayLike, b: Scalar | Pattern\n- ):\n+ ) -> None:\n \"\"\"\n Raises an error if the two arrays (a,b) cannot be compared.\n Otherwise, returns the comparison result as expected.\ndiff --git a/pandas/core/array_algos/take.py b/pandas/core/array_algos/take.py\nindex 188725f003f1e..6f7d7d85c4f2c 100644\n--- a/pandas/core/array_algos/take.py\n+++ b/pandas/core/array_algos/take.py\n@@ -337,7 +337,7 @@ def _get_take_nd_function(\n \n if func is None:\n \n- def func(arr, indexer, out, fill_value=np.nan):\n+ def func(arr, indexer, out, fill_value=np.nan) -> None:\n indexer = ensure_platform_int(indexer)\n _take_nd_object(\n arr, indexer, out, axis=axis, fill_value=fill_value, mask_info=mask_info\n@@ -349,7 +349,7 @@ def func(arr, indexer, out, fill_value=np.nan):\n def _view_wrapper(f, arr_dtype=None, out_dtype=None, fill_wrap=None):\n def wrapper(\n arr: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=np.nan\n- ):\n+ ) -> None:\n if arr_dtype is not None:\n arr = arr.view(arr_dtype)\n if out_dtype is not None:\n@@ -364,7 +364,7 @@ def wrapper(\n def _convert_wrapper(f, conv_dtype):\n def wrapper(\n arr: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=np.nan\n- ):\n+ ) -> None:\n if conv_dtype == object:\n # GH#39755 avoid casting dt64/td64 to integers\n arr = ensure_wrapped_if_datetimelike(arr)\n@@ -506,7 +506,7 @@ def _take_nd_object(\n axis: int,\n fill_value,\n mask_info,\n-):\n+) -> None:\n if mask_info is not None:\n mask, needs_masking = mask_info\n else:\ndiff --git a/pandas/core/arrays/_mixins.py b/pandas/core/arrays/_mixins.py\nindex b15e0624963ea..45bd1c583f4d5 100644\n--- a/pandas/core/arrays/_mixins.py\n+++ b/pandas/core/arrays/_mixins.py\n@@ -259,7 +259,7 @@ def _validate_shift_value(self, fill_value):\n # we can remove this and use validate_fill_value directly\n return self._validate_scalar(fill_value)\n \n- def __setitem__(self, key, value):\n+ def __setitem__(self, key, value) -> None:\n key = check_array_indexer(self, key)\n value = self._validate_setitem_value(value)\n self._ndarray[key] = value\ndiff --git a/pandas/core/arrays/arrow/_arrow_utils.py b/pandas/core/arrays/arrow/_arrow_utils.py\nindex e0f242e2ced5d..ac7e31339e37b 100644\n--- a/pandas/core/arrays/arrow/_arrow_utils.py\n+++ b/pandas/core/arrays/arrow/_arrow_utils.py\n@@ -14,7 +14,7 @@\n from pandas.core.arrays.interval import VALID_CLOSED\n \n \n-def fallback_performancewarning(version: str | None = None):\n+def fallback_performancewarning(version: str | None = None) -> None:\n \"\"\"\n Raise a PerformanceWarning for falling back to ExtensionArray's\n non-pyarrow method\ndiff --git a/pandas/core/arrays/base.py b/pandas/core/arrays/base.py\nindex 4274e6e5a911c..65772ab206489 100644\n--- a/pandas/core/arrays/base.py\n+++ b/pandas/core/arrays/base.py\n@@ -1699,7 +1699,7 @@ def _create_arithmetic_method(cls, op):\n raise AbstractMethodError(cls)\n \n @classmethod\n- def _add_arithmetic_ops(cls):\n+ def _add_arithmetic_ops(cls) -> None:\n setattr(cls, \"__add__\", cls._create_arithmetic_method(operator.add))\n setattr(cls, \"__radd__\", cls._create_arithmetic_method(roperator.radd))\n setattr(cls, \"__sub__\", cls._create_arithmetic_method(operator.sub))\n@@ -1724,7 +1724,7 @@ def _create_comparison_method(cls, op):\n raise AbstractMethodError(cls)\n \n @classmethod\n- def _add_comparison_ops(cls):\n+ def _add_comparison_ops(cls) -> None:\n setattr(cls, \"__eq__\", cls._create_comparison_method(operator.eq))\n setattr(cls, \"__ne__\", cls._create_comparison_method(operator.ne))\n setattr(cls, \"__lt__\", cls._create_comparison_method(operator.lt))\n@@ -1737,7 +1737,7 @@ def _create_logical_method(cls, op):\n raise AbstractMethodError(cls)\n \n @classmethod\n- def _add_logical_ops(cls):\n+ def _add_logical_ops(cls) -> None:\n setattr(cls, \"__and__\", cls._create_logical_method(operator.and_))\n setattr(cls, \"__rand__\", cls._create_logical_method(roperator.rand_))\n setattr(cls, \"__or__\", cls._create_logical_method(operator.or_))\ndiff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py\nindex 70699c45e0c36..ddc70889ba607 100644\n--- a/pandas/core/arrays/categorical.py\n+++ b/pandas/core/arrays/categorical.py\n@@ -738,7 +738,7 @@ def categories(self):\n return self.dtype.categories\n \n @categories.setter\n- def categories(self, categories):\n+ def categories(self, categories) -> None:\n new_dtype = CategoricalDtype(categories, ordered=self.ordered)\n if self.dtype.categories is not None and len(self.dtype.categories) != len(\n new_dtype.categories\n@@ -776,7 +776,7 @@ def codes(self) -> np.ndarray:\n v.flags.writeable = False\n return v\n \n- def _set_categories(self, categories, fastpath=False):\n+ def _set_categories(self, categories, fastpath=False) -> None:\n \"\"\"\n Sets new categories inplace\n \n@@ -1700,7 +1700,7 @@ def _internal_get_values(self):\n return self.categories.astype(\"object\").take(self._codes, fill_value=np.nan)\n return np.array(self)\n \n- def check_for_ordered(self, op):\n+ def check_for_ordered(self, op) -> None:\n \"\"\"assert that we are ordered\"\"\"\n if not self.ordered:\n raise TypeError(\n@@ -1931,7 +1931,7 @@ def _codes(self) -> np.ndarray:\n return self._ndarray\n \n @_codes.setter\n- def _codes(self, value: np.ndarray):\n+ def _codes(self, value: np.ndarray) -> None:\n warn(\n \"Setting the codes on a Categorical is deprecated and will raise in \"\n \"a future version. Create a new Categorical object instead\",\n@@ -1985,7 +1985,7 @@ def __contains__(self, key) -> bool:\n # ------------------------------------------------------------------\n # Rendering Methods\n \n- def _formatter(self, boxed: bool = False):\n+ def _formatter(self, boxed: bool = False) -> None:\n # Defer to CategoricalFormatter's formatter.\n return None\n \n@@ -2713,7 +2713,7 @@ def __init__(self, data) -> None:\n self._freeze()\n \n @staticmethod\n- def _validate(data):\n+ def _validate(data) -> None:\n if not is_categorical_dtype(data.dtype):\n raise AttributeError(\"Can only use .cat accessor with a 'category' dtype\")\n \ndiff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py\nindex d354d28d0f46f..502845e63e988 100644\n--- a/pandas/core/arrays/datetimelike.py\n+++ b/pandas/core/arrays/datetimelike.py\n@@ -410,7 +410,7 @@ def __setitem__( # type: ignore[override]\n \n self._maybe_clear_freq()\n \n- def _maybe_clear_freq(self):\n+ def _maybe_clear_freq(self) -> None:\n # inplace operations like __setitem__ may invalidate the freq of\n # DatetimeArray and TimedeltaArray\n pass\n@@ -924,7 +924,7 @@ def freq(self):\n return self._freq\n \n @freq.setter\n- def freq(self, value):\n+ def freq(self, value) -> None:\n if value is not None:\n value = to_offset(value)\n self._validate_frequency(self, value)\n@@ -976,7 +976,7 @@ def resolution(self) -> str:\n return self._resolution_obj.attrname # type: ignore[union-attr]\n \n @classmethod\n- def _validate_frequency(cls, index, freq, **kwargs):\n+ def _validate_frequency(cls, index, freq, **kwargs) -> None:\n \"\"\"\n Validate that a frequency is compatible with the values of a given\n Datetime Array/Index or Timedelta Array/Index\ndiff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py\nindex c6d0625de00fa..1fe46b5787479 100644\n--- a/pandas/core/arrays/datetimes.py\n+++ b/pandas/core/arrays/datetimes.py\n@@ -523,7 +523,7 @@ def _unbox_scalar(self, value, setitem: bool = False) -> np.datetime64:\n def _scalar_from_string(self, value) -> Timestamp | NaTType:\n return Timestamp(value, tz=self.tz)\n \n- def _check_compatible_with(self, other, setitem: bool = False):\n+ def _check_compatible_with(self, other, setitem: bool = False) -> None:\n if other is NaT:\n return\n self._assert_tzawareness_compat(other)\ndiff --git a/pandas/core/arrays/interval.py b/pandas/core/arrays/interval.py\nindex e58032c48f8d3..0051128395313 100644\n--- a/pandas/core/arrays/interval.py\n+++ b/pandas/core/arrays/interval.py\n@@ -602,7 +602,7 @@ def from_tuples(\n \n return cls.from_arrays(left, right, inclusive, copy=False, dtype=dtype)\n \n- def _validate(self):\n+ def _validate(self) -> None:\n \"\"\"\n Verify that the IntervalArray is valid.\n \n@@ -696,7 +696,7 @@ def __getitem__(\n raise ValueError(\"multi-dimensional indexing not allowed\")\n return self._shallow_copy(left, right)\n \n- def __setitem__(self, key, value):\n+ def __setitem__(self, key, value) -> None:\n value_left, value_right = self._validate_setitem_value(value)\n key = check_array_indexer(self, key)\n \ndiff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py\nindex 7e6ea07c154cd..5574ff46cf15b 100644\n--- a/pandas/core/arrays/period.py\n+++ b/pandas/core/arrays/period.py\n@@ -339,7 +339,7 @@ def _unbox_scalar( # type: ignore[override]\n def _scalar_from_string(self, value: str) -> Period:\n return Period(value, freq=self.freq)\n \n- def _check_compatible_with(self, other, setitem: bool = False):\n+ def _check_compatible_with(self, other, setitem: bool = False) -> None:\n if other is NaT:\n return\n self._require_matching_freq(other)\ndiff --git a/pandas/core/arrays/sparse/accessor.py b/pandas/core/arrays/sparse/accessor.py\nindex 41af7d4ccd506..0fb8b4413b1d2 100644\n--- a/pandas/core/arrays/sparse/accessor.py\n+++ b/pandas/core/arrays/sparse/accessor.py\n@@ -33,7 +33,7 @@ class SparseAccessor(BaseAccessor, PandasDelegate):\n Accessor for SparseSparse from other sparse matrix data types.\n \"\"\"\n \n- def _validate(self, data):\n+ def _validate(self, data) -> None:\n if not isinstance(data.dtype, SparseDtype):\n raise AttributeError(self._validation_msg)\n \n@@ -222,7 +222,7 @@ class SparseFrameAccessor(BaseAccessor, PandasDelegate):\n .. versionadded:: 0.25.0\n \"\"\"\n \n- def _validate(self, data):\n+ def _validate(self, data) -> None:\n dtypes = data.dtypes\n if not all(isinstance(t, SparseDtype) for t in dtypes):\n raise AttributeError(self._validation_msg)\ndiff --git a/pandas/core/arrays/sparse/array.py b/pandas/core/arrays/sparse/array.py\nindex 26c577886f174..88b83ad3f05a3 100644\n--- a/pandas/core/arrays/sparse/array.py\n+++ b/pandas/core/arrays/sparse/array.py\n@@ -605,7 +605,7 @@ def __array__(self, dtype: NpDtype | None = None) -> np.ndarray:\n out[self.sp_index.indices] = self.sp_values\n return out\n \n- def __setitem__(self, key, value):\n+ def __setitem__(self, key, value) -> None:\n # I suppose we could allow setting of non-fill_value elements.\n # TODO(SparseArray.__setitem__): remove special cases in\n # ExtensionBlock.where\n@@ -657,7 +657,7 @@ def fill_value(self):\n return self.dtype.fill_value\n \n @fill_value.setter\n- def fill_value(self, value):\n+ def fill_value(self, value) -> None:\n self._dtype = SparseDtype(self.dtype.subtype, value)\n \n @property\n@@ -1387,7 +1387,7 @@ def _where(self, mask, value):\n # ------------------------------------------------------------------------\n # IO\n # ------------------------------------------------------------------------\n- def __setstate__(self, state):\n+ def __setstate__(self, state) -> None:\n \"\"\"Necessary for making this object picklable\"\"\"\n if isinstance(state, tuple):\n # Compat for pandas < 0.24.0\n@@ -1801,7 +1801,7 @@ def __repr__(self) -> str:\n pp_index = printing.pprint_thing(self.sp_index)\n return f\"{pp_str}\\nFill: {pp_fill}\\n{pp_index}\"\n \n- def _formatter(self, boxed=False):\n+ def _formatter(self, boxed=False) -> None:\n # Defer to the formatter from the GenericArrayFormatter calling us.\n # This will infer the correct formatter from the dtype of the values.\n return None\ndiff --git a/pandas/core/arrays/sparse/dtype.py b/pandas/core/arrays/sparse/dtype.py\nindex b6bb5faeebdee..652c9f3020759 100644\n--- a/pandas/core/arrays/sparse/dtype.py\n+++ b/pandas/core/arrays/sparse/dtype.py\n@@ -148,7 +148,7 @@ def fill_value(self):\n \"\"\"\n return self._fill_value\n \n- def _check_fill_value(self):\n+ def _check_fill_value(self) -> None:\n if not is_scalar(self._fill_value):\n raise ValueError(\n f\"fill_value must be a scalar. Got {self._fill_value} instead\"\ndiff --git a/pandas/core/arrays/sparse/scipy_sparse.py b/pandas/core/arrays/sparse/scipy_sparse.py\nindex 88e1778d4c854..efe5ffb416a2e 100644\n--- a/pandas/core/arrays/sparse/scipy_sparse.py\n+++ b/pandas/core/arrays/sparse/scipy_sparse.py\n@@ -28,7 +28,7 @@\n import scipy.sparse\n \n \n-def _check_is_partition(parts: Iterable, whole: Iterable):\n+def _check_is_partition(parts: Iterable, whole: Iterable) -> None:\n whole = set(whole)\n parts = [set(x) for x in parts]\n if set.intersection(*parts) != set():\ndiff --git a/pandas/core/arrays/string_.py b/pandas/core/arrays/string_.py\nindex 45683d83a1303..8880ea6ef5935 100644\n--- a/pandas/core/arrays/string_.py\n+++ b/pandas/core/arrays/string_.py\n@@ -304,7 +304,7 @@ def __init__(self, values, copy=False) -> None:\n self._validate()\n NDArrayBacked.__init__(self, self._ndarray, StringDtype(storage=\"python\"))\n \n- def _validate(self):\n+ def _validate(self) -> None:\n \"\"\"Validate that we only store NA or strings.\"\"\"\n if len(self._ndarray) and not lib.is_string_array(self._ndarray, skipna=True):\n raise ValueError(\"StringArray requires a sequence of strings or pandas.NA\")\n@@ -379,7 +379,7 @@ def _values_for_factorize(self):\n arr[mask] = -1\n return arr, -1\n \n- def __setitem__(self, key, value):\n+ def __setitem__(self, key, value) -> None:\n value = extract_array(value, extract_numpy=True)\n if isinstance(value, type(self)):\n # extract_array doesn't extract PandasArray subclasses\ndiff --git a/pandas/core/arrays/timedeltas.py b/pandas/core/arrays/timedeltas.py\nindex 68f0d73b8556c..38bb14cb7cb0d 100644\n--- a/pandas/core/arrays/timedeltas.py\n+++ b/pandas/core/arrays/timedeltas.py\n@@ -442,7 +442,7 @@ def _format_native_types(\n # ----------------------------------------------------------------\n # Arithmetic Methods\n \n- def _add_offset(self, other):\n+ def _add_offset(self, other) -> None:\n assert not isinstance(other, Tick)\n raise TypeError(\n f\"cannot add the type {type(other).__name__} to a {type(self).__name__}\"\ndiff --git a/pandas/core/base.py b/pandas/core/base.py\nindex 3d18194d14bec..db100b096add8 100644\n--- a/pandas/core/base.py\n+++ b/pandas/core/base.py\n@@ -154,14 +154,14 @@ class NoNewAttributesMixin:\n `object.__setattr__(self, key, value)`.\n \"\"\"\n \n- def _freeze(self):\n+ def _freeze(self) -> None:\n \"\"\"\n Prevents setting additional attributes.\n \"\"\"\n object.__setattr__(self, \"__frozen\", True)\n \n # prevent adding any attribute via s.xxx.new_attribute = ...\n- def __setattr__(self, key: str, value):\n+ def __setattr__(self, key: str, value) -> None:\n # _cache is used by a decorator\n # We need to check both 1.) cls.__dict__ and 2.) getattr(self, key)\n # because\ndiff --git a/pandas/core/common.py b/pandas/core/common.py\nindex 707201153e44a..980e7a79414ba 100644\n--- a/pandas/core/common.py\n+++ b/pandas/core/common.py\n@@ -553,7 +553,7 @@ def temp_setattr(obj, attr: str, value) -> Iterator[None]:\n setattr(obj, attr, old_value)\n \n \n-def require_length_match(data, index: Index):\n+def require_length_match(data, index: Index) -> None:\n \"\"\"\n Check the length of data matches the length of the index.\n \"\"\"\n@@ -665,7 +665,9 @@ def resolve_numeric_only(numeric_only: bool | None | lib.NoDefault) -> bool:\n return result\n \n \n-def deprecate_numeric_only_default(cls: type, name: str, deprecate_none: bool = False):\n+def deprecate_numeric_only_default(\n+ cls: type, name: str, deprecate_none: bool = False\n+) -> None:\n \"\"\"Emit FutureWarning message for deprecation of numeric_only.\n \n See GH#46560 for details on the deprecation.\ndiff --git a/pandas/core/computation/eval.py b/pandas/core/computation/eval.py\nindex d82cc37b90ad4..9e3f2849a6b40 100644\n--- a/pandas/core/computation/eval.py\n+++ b/pandas/core/computation/eval.py\n@@ -67,7 +67,7 @@ def _check_engine(engine: str | None) -> str:\n return engine\n \n \n-def _check_parser(parser: str):\n+def _check_parser(parser: str) -> None:\n \"\"\"\n Make sure a valid parser is passed.\n \n@@ -86,7 +86,7 @@ def _check_parser(parser: str):\n )\n \n \n-def _check_resolvers(resolvers):\n+def _check_resolvers(resolvers) -> None:\n if resolvers is not None:\n for resolver in resolvers:\n if not hasattr(resolver, \"__getitem__\"):\n@@ -97,7 +97,7 @@ def _check_resolvers(resolvers):\n )\n \n \n-def _check_expression(expr):\n+def _check_expression(expr) -> None:\n \"\"\"\n Make sure an expression is not an empty string\n \n@@ -144,7 +144,7 @@ def _convert_expression(expr) -> str:\n return s\n \n \n-def _check_for_locals(expr: str, stack_level: int, parser: str):\n+def _check_for_locals(expr: str, stack_level: int, parser: str) -> None:\n \n at_top_of_stack = stack_level == 0\n not_pandas_parser = parser != \"pandas\"\ndiff --git a/pandas/core/computation/expressions.py b/pandas/core/computation/expressions.py\nindex 9e180f11c4211..e82bec47c6ac5 100644\n--- a/pandas/core/computation/expressions.py\n+++ b/pandas/core/computation/expressions.py\n@@ -38,7 +38,7 @@\n _MIN_ELEMENTS = 1_000_000\n \n \n-def set_use_numexpr(v=True):\n+def set_use_numexpr(v=True) -> None:\n # set/unset to use numexpr\n global USE_NUMEXPR\n if NUMEXPR_INSTALLED:\n@@ -51,7 +51,7 @@ def set_use_numexpr(v=True):\n _where = _where_numexpr if USE_NUMEXPR else _where_standard\n \n \n-def set_numexpr_threads(n=None):\n+def set_numexpr_threads(n=None) -> None:\n # if we are using numexpr, set the threads to n\n # otherwise reset\n if NUMEXPR_INSTALLED and USE_NUMEXPR:\ndiff --git a/pandas/core/computation/ops.py b/pandas/core/computation/ops.py\nindex 3a556b57ea5a5..4215cc927ebf3 100644\n--- a/pandas/core/computation/ops.py\n+++ b/pandas/core/computation/ops.py\n@@ -107,7 +107,7 @@ def _resolve_name(self):\n )\n return res\n \n- def update(self, value):\n+ def update(self, value) -> None:\n \"\"\"\n search order for local (i.e., @variable) variables:\n \n@@ -162,7 +162,7 @@ def value(self):\n return self._value\n \n @value.setter\n- def value(self, new_value):\n+ def value(self, new_value) -> None:\n self._value = new_value\n \n @property\n@@ -321,7 +321,7 @@ def _not_in(x, y):\n _binary_ops_dict.update(d)\n \n \n-def _cast_inplace(terms, acceptable_dtypes, dtype):\n+def _cast_inplace(terms, acceptable_dtypes, dtype) -> None:\n \"\"\"\n Cast an expression inplace.\n \n@@ -480,7 +480,7 @@ def stringify(value):\n v = v.tz_convert(\"UTC\")\n self.lhs.update(v)\n \n- def _disallow_scalar_only_bool_ops(self):\n+ def _disallow_scalar_only_bool_ops(self) -> None:\n rhs = self.rhs\n lhs = self.lhs\n \ndiff --git a/pandas/core/computation/pytables.py b/pandas/core/computation/pytables.py\nindex 29af322ba0b42..7601f607b7311 100644\n--- a/pandas/core/computation/pytables.py\n+++ b/pandas/core/computation/pytables.py\n@@ -107,7 +107,7 @@ def __init__(self, op: str, lhs, rhs, queryables: dict[str, Any], encoding) -> N\n self.encoding = encoding\n self.condition = None\n \n- def _disallow_scalar_only_bool_ops(self):\n+ def _disallow_scalar_only_bool_ops(self) -> None:\n pass\n \n def prune(self, klass):\n@@ -256,7 +256,7 @@ def stringify(value):\n else:\n raise TypeError(f\"Cannot compare {v} of type {type(v)} to {kind} column\")\n \n- def convert_values(self):\n+ def convert_values(self) -> None:\n pass\n \n \ndiff --git a/pandas/core/config_init.py b/pandas/core/config_init.py\nindex 47cf64ba24022..6413a09f30ffd 100644\n--- a/pandas/core/config_init.py\n+++ b/pandas/core/config_init.py\n@@ -37,7 +37,7 @@\n \"\"\"\n \n \n-def use_bottleneck_cb(key):\n+def use_bottleneck_cb(key) -> None:\n from pandas.core import nanops\n \n nanops.set_use_bottleneck(cf.get_option(key))\n@@ -51,7 +51,7 @@ def use_bottleneck_cb(key):\n \"\"\"\n \n \n-def use_numexpr_cb(key):\n+def use_numexpr_cb(key) -> None:\n from pandas.core.computation import expressions\n \n expressions.set_use_numexpr(cf.get_option(key))\n@@ -65,7 +65,7 @@ def use_numexpr_cb(key):\n \"\"\"\n \n \n-def use_numba_cb(key):\n+def use_numba_cb(key) -> None:\n from pandas.core.util import numba_\n \n numba_.set_use_numba(cf.get_option(key))\n@@ -329,7 +329,7 @@ def use_numba_cb(key):\n \"\"\"\n \n \n-def table_schema_cb(key):\n+def table_schema_cb(key) -> None:\n from pandas.io.formats.printing import enable_data_resource_formatter\n \n enable_data_resource_formatter(cf.get_option(key))\n@@ -362,7 +362,7 @@ def is_terminal() -> bool:\n validator=is_one_of_factory([None, is_callable]),\n )\n \n- def _deprecate_column_space(key):\n+ def _deprecate_column_space(key) -> None:\n warnings.warn(\n \"column_space is deprecated and will be removed \"\n \"in a future version. Use df.to_string(col_space=...) \"\n@@ -387,7 +387,7 @@ def _deprecate_column_space(key):\n )\n cf.register_option(\"max_categories\", 8, pc_max_categories_doc, validator=is_int)\n \n- def _deprecate_negative_int_max_colwidth(key):\n+ def _deprecate_negative_int_max_colwidth(key) -> None:\n value = cf.get_option(key)\n if value is not None and value < 0:\n warnings.warn(\n@@ -500,7 +500,7 @@ def _deprecate_negative_int_max_colwidth(key):\n # or we'll hit circular deps.\n \n \n-def use_inf_as_na_cb(key):\n+def use_inf_as_na_cb(key) -> None:\n from pandas.core.dtypes.missing import _use_inf_as_na\n \n _use_inf_as_na(key)\n@@ -720,7 +720,7 @@ def use_inf_as_na_cb(key):\n \"\"\"\n \n \n-def register_plotting_backend_cb(key):\n+def register_plotting_backend_cb(key) -> None:\n if key == \"matplotlib\":\n # We defer matplotlib validation, since it's the default\n return\n@@ -746,7 +746,7 @@ def register_plotting_backend_cb(key):\n \"\"\"\n \n \n-def register_converter_cb(key):\n+def register_converter_cb(key) -> None:\n from pandas.plotting import (\n deregister_matplotlib_converters,\n register_matplotlib_converters,\ndiff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py\nindex d356a858a82fb..d0b7d10ce1dda 100644\n--- a/pandas/core/dtypes/cast.py\n+++ b/pandas/core/dtypes/cast.py\n@@ -231,7 +231,7 @@ def _maybe_unbox_datetimelike(value: Scalar, dtype: DtypeObj) -> Scalar:\n return value\n \n \n-def _disallow_mismatched_datetimelike(value, dtype: DtypeObj):\n+def _disallow_mismatched_datetimelike(value, dtype: DtypeObj) -> None:\n \"\"\"\n numpy allows np.array(dt64values, dtype=\"timedelta64[ns]\") and\n vice-versa, but we do not want to allow this, so we need to\n@@ -978,7 +978,7 @@ def maybe_upcast(\n return upcast_values, fill_value # type: ignore[return-value]\n \n \n-def invalidate_string_dtypes(dtype_set: set[DtypeObj]):\n+def invalidate_string_dtypes(dtype_set: set[DtypeObj]) -> None:\n \"\"\"\n Change string like dtypes to object for\n ``DataFrame.select_dtypes()``.\ndiff --git a/pandas/core/dtypes/dtypes.py b/pandas/core/dtypes/dtypes.py\nindex 32594854f49ae..348f6ef131864 100644\n--- a/pandas/core/dtypes/dtypes.py\n+++ b/pandas/core/dtypes/dtypes.py\n@@ -970,7 +970,7 @@ def __eq__(self, other: Any) -> bool:\n def __ne__(self, other: Any) -> bool:\n return not self.__eq__(other)\n \n- def __setstate__(self, state):\n+ def __setstate__(self, state) -> None:\n # for pickle compat. __getstate__ is defined in the\n # PandasExtensionDtype superclass and uses the public properties to\n # pickle -> need to set the settable private ones here (see GH26067)\n@@ -1249,7 +1249,7 @@ def __eq__(self, other: Any) -> bool:\n \n return is_dtype_equal(self.subtype, other.subtype)\n \n- def __setstate__(self, state):\n+ def __setstate__(self, state) -> None:\n # for pickle compat. __get_state__ is defined in the\n # PandasExtensionDtype superclass and uses the public properties to\n # pickle -> need to set the settable private ones here (see GH26067)\ndiff --git a/pandas/core/dtypes/missing.py b/pandas/core/dtypes/missing.py\nindex 37b42ad66c027..0def7faefa095 100644\n--- a/pandas/core/dtypes/missing.py\n+++ b/pandas/core/dtypes/missing.py\n@@ -233,7 +233,7 @@ def _isna(obj, inf_as_na: bool = False):\n return False\n \n \n-def _use_inf_as_na(key):\n+def _use_inf_as_na(key) -> None:\n \"\"\"\n Option change callback for na/inf behaviour.\n \ndiff --git a/pandas/core/flags.py b/pandas/core/flags.py\nindex 001cd3d41177a..cc779d98716c8 100644\n--- a/pandas/core/flags.py\n+++ b/pandas/core/flags.py\n@@ -81,7 +81,7 @@ def allows_duplicate_labels(self) -> bool:\n return self._allows_duplicate_labels\n \n @allows_duplicate_labels.setter\n- def allows_duplicate_labels(self, value: bool):\n+ def allows_duplicate_labels(self, value: bool) -> None:\n value = bool(value)\n obj = self._obj()\n if obj is None:\n@@ -99,7 +99,7 @@ def __getitem__(self, key):\n \n return getattr(self, key)\n \n- def __setitem__(self, key, value):\n+ def __setitem__(self, key, value) -> None:\n if key not in self._keys:\n raise ValueError(f\"Unknown flag {key}. Must be one of {self._keys}\")\n setattr(self, key, value)\ndiff --git a/pandas/core/frame.py b/pandas/core/frame.py\nindex 932805463d1c3..ddfcc69a1a1f0 100644\n--- a/pandas/core/frame.py\n+++ b/pandas/core/frame.py\n@@ -3831,7 +3831,7 @@ def __setitem__(self, key, value):\n # set column\n self._set_item(key, value)\n \n- def _setitem_slice(self, key: slice, value):\n+ def _setitem_slice(self, key: slice, value) -> None:\n # NB: we can't just use self.loc[key] = value because that\n # operates on labels and we need to operate positional for\n # backwards-compat, xref GH#31469\n@@ -3923,7 +3923,7 @@ def igetitem(obj, i: int):\n finally:\n self.columns = orig_columns\n \n- def _setitem_frame(self, key, value):\n+ def _setitem_frame(self, key, value) -> None:\n # support boolean setting with DataFrame input, e.g.\n # df[df > df2] = 0\n if isinstance(key, np.ndarray):\ndiff --git a/pandas/core/generic.py b/pandas/core/generic.py\nindex a10cfe1c615fa..5259bcf440143 100644\n--- a/pandas/core/generic.py\n+++ b/pandas/core/generic.py\n@@ -3887,7 +3887,7 @@ def _check_is_chained_assignment_possible(self) -> bool_t:\n return False\n \n @final\n- def _check_setitem_copy(self, t=\"setting\", force=False):\n+ def _check_setitem_copy(self, t=\"setting\", force=False) -> None:\n \"\"\"\n \n Parameters\n@@ -3999,7 +3999,7 @@ def __delitem__(self, key) -> None:\n # Unsorted\n \n @final\n- def _check_inplace_and_allows_duplicate_labels(self, inplace):\n+ def _check_inplace_and_allows_duplicate_labels(self, inplace) -> None:\n if inplace and not self.flags.allows_duplicate_labels:\n raise ValueError(\n \"Cannot specify 'inplace=True' when \"\n@@ -5679,7 +5679,7 @@ def _protect_consolidate(self, f):\n def _consolidate_inplace(self) -> None:\n \"\"\"Consolidate data in place and return None\"\"\"\n \n- def f():\n+ def f() -> None:\n self._mgr = self._mgr.consolidate()\n \n self._protect_consolidate(f)\ndiff --git a/pandas/core/groupby/grouper.py b/pandas/core/groupby/grouper.py\nindex e524021f3a1b8..94bb6f6743fc8 100644\n--- a/pandas/core/groupby/grouper.py\n+++ b/pandas/core/groupby/grouper.py\n@@ -938,7 +938,7 @@ def _convert_grouper(axis: Index, grouper):\n return grouper\n \n \n-def _check_deprecated_resample_kwargs(kwargs, origin):\n+def _check_deprecated_resample_kwargs(kwargs, origin) -> None:\n \"\"\"\n Check for use of deprecated parameters in ``resample`` and related functions.\n \ndiff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py\nindex d056b4b03d904..410f046ff6767 100644\n--- a/pandas/core/groupby/ops.py\n+++ b/pandas/core/groupby/ops.py\n@@ -222,7 +222,7 @@ def _get_cython_vals(self, values: np.ndarray) -> np.ndarray:\n return values\n \n # TODO: general case implementation overridable by EAs.\n- def _disallow_invalid_ops(self, dtype: DtypeObj, is_numeric: bool = False):\n+ def _disallow_invalid_ops(self, dtype: DtypeObj, is_numeric: bool = False) -> None:\n \"\"\"\n Check if we can do this operation with our cython functions.\n \ndiff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py\nindex 0393c9d07cc74..f05c216bf6494 100644\n--- a/pandas/core/indexes/base.py\n+++ b/pandas/core/indexes/base.py\n@@ -661,7 +661,7 @@ def _dtype_to_subclass(cls, dtype: DtypeObj):\n \"\"\"\n \n @property\n- def asi8(self):\n+ def asi8(self) -> npt.NDArray[np.int64] | None:\n \"\"\"\n Integer representation of the values.\n \n@@ -1726,7 +1726,7 @@ def name(self):\n return self._name\n \n @name.setter\n- def name(self, value: Hashable):\n+ def name(self, value: Hashable) -> None:\n if self._no_setting_name:\n # Used in MultiIndex.levels to avoid silently ignoring name updates.\n raise RuntimeError(\n@@ -3192,7 +3192,7 @@ def _get_reconciled_name_object(self, other):\n return self\n \n @final\n- def _validate_sort_keyword(self, sort):\n+ def _validate_sort_keyword(self, sort) -> None:\n if sort not in [None, False]:\n raise ValueError(\n \"The 'sort' keyword only takes the values of \"\n@@ -3200,7 +3200,7 @@ def _validate_sort_keyword(self, sort):\n )\n \n @final\n- def _deprecate_dti_setop(self, other: Index, setop: str_t):\n+ def _deprecate_dti_setop(self, other: Index, setop: str_t) -> None:\n \"\"\"\n Deprecate setop behavior between timezone-aware DatetimeIndexes with\n mismatched timezones.\n@@ -5929,7 +5929,7 @@ def get_value(self, series: Series, key):\n \n return self._get_values_for_loc(series, loc, key)\n \n- def _check_indexing_error(self, key):\n+ def _check_indexing_error(self, key) -> None:\n if not is_scalar(key):\n # if key is not a scalar, directly raise an error (the code below\n # would convert to numpy arrays and raise later any way) - GH29926\n@@ -5957,7 +5957,7 @@ def _get_values_for_loc(self, series: Series, loc, key):\n return series.iloc[loc]\n \n @final\n- def set_value(self, arr, key, value):\n+ def set_value(self, arr, key, value) -> None:\n \"\"\"\n Fast lookup of value from 1-dimensional ndarray.\n \n@@ -6590,7 +6590,7 @@ def _maybe_cast_listlike_indexer(self, target) -> Index:\n return ensure_index(target)\n \n @final\n- def _validate_indexer(self, form: str_t, key, kind: str_t):\n+ def _validate_indexer(self, form: str_t, key, kind: str_t) -> None:\n \"\"\"\n If we are positional indexer, validate that we have appropriate\n typed bounds must be an integer.\ndiff --git a/pandas/core/indexes/extension.py b/pandas/core/indexes/extension.py\nindex 28a0b43d5b02b..120c2b0eda11a 100644\n--- a/pandas/core/indexes/extension.py\n+++ b/pandas/core/indexes/extension.py\n@@ -74,7 +74,7 @@ def fget(self):\n return Index(result, name=self.name)\n return result\n \n- def fset(self, value):\n+ def fset(self, value) -> None:\n setattr(self._data, name, value)\n \n fget.__name__ = name\ndiff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py\nindex 15d06ef3bc8e5..2d1ca153b854b 100644\n--- a/pandas/core/indexes/multi.py\n+++ b/pandas/core/indexes/multi.py\n@@ -1423,7 +1423,7 @@ def format(\n def _get_names(self) -> FrozenList:\n return FrozenList(self._names)\n \n- def _set_names(self, names, *, level=None, validate: bool = True):\n+ def _set_names(self, names, *, level=None, validate: bool = True) -> None:\n \"\"\"\n Set new names on index. Each name has to be a hashable type.\n \ndiff --git a/pandas/core/indexes/range.py b/pandas/core/indexes/range.py\nindex 5b384fbc97c1a..3a530368e601c 100644\n--- a/pandas/core/indexes/range.py\n+++ b/pandas/core/indexes/range.py\n@@ -218,7 +218,7 @@ def _format_attrs(self):\n attrs.append((\"name\", ibase.default_pprint(self.name)))\n return attrs\n \n- def _format_data(self, name=None):\n+ def _format_data(self, name=None) -> None:\n # we are formatting thru the attributes\n return None\n \ndiff --git a/pandas/core/indexing.py b/pandas/core/indexing.py\nindex 09fa08339bd43..22ca69f4ce133 100644\n--- a/pandas/core/indexing.py\n+++ b/pandas/core/indexing.py\n@@ -754,7 +754,7 @@ def _maybe_mask_setitem_value(self, indexer, value):\n return indexer, value\n \n @final\n- def _ensure_listlike_indexer(self, key, axis=None, value=None):\n+ def _ensure_listlike_indexer(self, key, axis=None, value=None) -> None:\n \"\"\"\n Ensure that a list-like of column labels are all present by adding them if\n they do not already exist.\n@@ -790,7 +790,7 @@ def _ensure_listlike_indexer(self, key, axis=None, value=None):\n self.obj._mgr = self.obj._mgr.reindex_axis(keys, axis=0, only_slice=True)\n \n @final\n- def __setitem__(self, key, value):\n+ def __setitem__(self, key, value) -> None:\n check_deprecated_indexers(key)\n if isinstance(key, tuple):\n key = tuple(list(x) if is_iterator(x) else x for x in key)\n@@ -1092,7 +1092,7 @@ class _LocIndexer(_LocationIndexer):\n # Key Checks\n \n @doc(_LocationIndexer._validate_key)\n- def _validate_key(self, key, axis: int):\n+ def _validate_key(self, key, axis: int) -> None:\n # valid for a collection of labels (we check their presence later)\n # slice of labels (where start-end in labels)\n # slice of integers (only if in the labels)\n@@ -1428,7 +1428,7 @@ class _iLocIndexer(_LocationIndexer):\n # -------------------------------------------------------------------\n # Key Checks\n \n- def _validate_key(self, key, axis: int):\n+ def _validate_key(self, key, axis: int) -> None:\n if com.is_bool_indexer(key):\n if hasattr(key, \"index\") and isinstance(key.index, Index):\n if key.index.inferred_type == \"integer\":\n@@ -1638,7 +1638,7 @@ def _get_setitem_indexer(self, key):\n \n # -------------------------------------------------------------------\n \n- def _setitem_with_indexer(self, indexer, value, name=\"iloc\"):\n+ def _setitem_with_indexer(self, indexer, value, name=\"iloc\") -> None:\n \"\"\"\n _setitem_with_indexer is for setting values on a Series/DataFrame\n using positional indexers.\n@@ -1868,7 +1868,7 @@ def _setitem_with_indexer_split_path(self, indexer, value, name: str):\n for loc in ilocs:\n self._setitem_single_column(loc, value, pi)\n \n- def _setitem_with_indexer_2d_value(self, indexer, value):\n+ def _setitem_with_indexer_2d_value(self, indexer, value) -> None:\n # We get here with np.ndim(value) == 2, excluding DataFrame,\n # which goes through _setitem_with_indexer_frame_value\n pi = indexer[0]\n@@ -1886,7 +1886,9 @@ def _setitem_with_indexer_2d_value(self, indexer, value):\n # setting with a list, re-coerces\n self._setitem_single_column(loc, value[:, i].tolist(), pi)\n \n- def _setitem_with_indexer_frame_value(self, indexer, value: DataFrame, name: str):\n+ def _setitem_with_indexer_frame_value(\n+ self, indexer, value: DataFrame, name: str\n+ ) -> None:\n ilocs = self._ensure_iterable_column_indexer(indexer[1])\n \n sub_indexer = list(indexer)\n@@ -1935,7 +1937,7 @@ def _setitem_with_indexer_frame_value(self, indexer, value: DataFrame, name: str\n \n self._setitem_single_column(loc, val, pi)\n \n- def _setitem_single_column(self, loc: int, value, plane_indexer):\n+ def _setitem_single_column(self, loc: int, value, plane_indexer) -> None:\n \"\"\"\n \n Parameters\n@@ -2013,7 +2015,7 @@ def _setitem_single_column(self, loc: int, value, plane_indexer):\n # TODO: what if we got here indirectly via loc?\n return\n \n- def _setitem_single_block(self, indexer, value, name: str):\n+ def _setitem_single_block(self, indexer, value, name: str) -> None:\n \"\"\"\n _setitem_with_indexer for the case when we have a single Block.\n \"\"\"\n@@ -2339,7 +2341,7 @@ def __getitem__(self, key):\n key = self._convert_key(key)\n return self.obj._get_value(*key, takeable=self._takeable)\n \n- def __setitem__(self, key, value):\n+ def __setitem__(self, key, value) -> None:\n if isinstance(key, tuple):\n key = tuple(com.apply_if_callable(x, self.obj) for x in key)\n else:\ndiff --git a/pandas/core/internals/array_manager.py b/pandas/core/internals/array_manager.py\nindex 7d2e4129461a7..d3302abe414f5 100644\n--- a/pandas/core/internals/array_manager.py\n+++ b/pandas/core/internals/array_manager.py\n@@ -177,7 +177,7 @@ def get_dtypes(self):\n def __getstate__(self):\n return self.arrays, self._axes\n \n- def __setstate__(self, state):\n+ def __setstate__(self, state) -> None:\n self.arrays = state[0]\n self._axes = state[1]\n \n@@ -815,7 +815,7 @@ def column_arrays(self) -> list[ArrayLike]:\n \n def iset(\n self, loc: int | slice | np.ndarray, value: ArrayLike, inplace: bool = False\n- ):\n+ ) -> None:\n \"\"\"\n Set new column(s).\n \n@@ -1336,7 +1336,7 @@ def _get_data_subset(self, predicate: Callable) -> SingleArrayManager:\n else:\n return self.make_empty()\n \n- def set_values(self, values: ArrayLike):\n+ def set_values(self, values: ArrayLike) -> None:\n \"\"\"\n Set (replace) the values of the SingleArrayManager in place.\n \ndiff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py\nindex 49efecec7472e..7941835bc6a6a 100644\n--- a/pandas/core/internals/blocks.py\n+++ b/pandas/core/internals/blocks.py\n@@ -215,7 +215,7 @@ def mgr_locs(self) -> BlockPlacement:\n return self._mgr_locs\n \n @mgr_locs.setter\n- def mgr_locs(self, new_mgr_locs: BlockPlacement):\n+ def mgr_locs(self, new_mgr_locs: BlockPlacement) -> None:\n self._mgr_locs = new_mgr_locs\n \n @final\n@@ -2156,7 +2156,7 @@ def new_block(values, placement, *, ndim: int) -> Block:\n return klass(values, ndim=ndim, placement=placement)\n \n \n-def check_ndim(values, placement: BlockPlacement, ndim: int):\n+def check_ndim(values, placement: BlockPlacement, ndim: int) -> None:\n \"\"\"\n ndim inference and validation.\n \ndiff --git a/pandas/core/internals/concat.py b/pandas/core/internals/concat.py\nindex 4a352d614e1d9..e99a710941d19 100644\n--- a/pandas/core/internals/concat.py\n+++ b/pandas/core/internals/concat.py\n@@ -359,7 +359,7 @@ def _get_mgr_concatenation_plan(mgr: BlockManager, indexers: dict[int, np.ndarra\n \n \n class JoinUnit:\n- def __init__(self, block: Block, shape: Shape, indexers=None):\n+ def __init__(self, block: Block, shape: Shape, indexers=None) -> None:\n # Passing shape explicitly is required for cases when block is None.\n # Note: block is None implies indexers is None, but not vice-versa\n if indexers is None:\ndiff --git a/pandas/core/internals/managers.py b/pandas/core/internals/managers.py\nindex 435992f7d5cff..1bf159fc51e5f 100644\n--- a/pandas/core/internals/managers.py\n+++ b/pandas/core/internals/managers.py\n@@ -1780,7 +1780,7 @@ def unpickle_block(values, mgr_locs, ndim: int) -> Block:\n \n self._post_setstate()\n \n- def _post_setstate(self):\n+ def _post_setstate(self) -> None:\n pass\n \n @cache_readonly\n@@ -1788,12 +1788,12 @@ def _block(self) -> Block:\n return self.blocks[0]\n \n @property\n- def _blknos(self):\n+ def _blknos(self) -> None:\n \"\"\"compat with BlockManager\"\"\"\n return None\n \n @property\n- def _blklocs(self):\n+ def _blklocs(self) -> None:\n \"\"\"compat with BlockManager\"\"\"\n return None\n \n@@ -1877,7 +1877,7 @@ def fast_xs(self, loc):\n \"\"\"\n raise NotImplementedError(\"Use series._values[loc] instead\")\n \n- def set_values(self, values: ArrayLike):\n+ def set_values(self, values: ArrayLike) -> None:\n \"\"\"\n Set the values of the single block in place.\n \ndiff --git a/pandas/core/internals/ops.py b/pandas/core/internals/ops.py\nindex 1160d3b2a8e3a..24fc51a96d9df 100644\n--- a/pandas/core/internals/ops.py\n+++ b/pandas/core/internals/ops.py\n@@ -86,7 +86,7 @@ def operate_blockwise(\n return new_mgr\n \n \n-def _reset_block_mgr_locs(nbs: list[Block], locs):\n+def _reset_block_mgr_locs(nbs: list[Block], locs) -> None:\n \"\"\"\n Reset mgr_locs to correspond to our original DataFrame.\n \"\"\"\ndiff --git a/pandas/core/missing.py b/pandas/core/missing.py\nindex 57b0a95f803b1..9eac047f003d0 100644\n--- a/pandas/core/missing.py\n+++ b/pandas/core/missing.py\n@@ -376,7 +376,7 @@ def _interpolate_1d(\n bounds_error: bool = False,\n order: int | None = None,\n **kwargs,\n-):\n+) -> None:\n \"\"\"\n Logic for the 1-d interpolation. The input\n indices and yvalues will each be 1-d arrays of the same length.\ndiff --git a/pandas/core/ops/array_ops.py b/pandas/core/ops/array_ops.py\nindex 2caaadbc05cff..d90a9a42e6454 100644\n--- a/pandas/core/ops/array_ops.py\n+++ b/pandas/core/ops/array_ops.py\n@@ -509,7 +509,7 @@ def maybe_prepare_scalar_for_op(obj, shape: Shape):\n }\n \n \n-def _bool_arith_check(op, a, b):\n+def _bool_arith_check(op, a, b) -> None:\n \"\"\"\n In contrast to numpy, pandas raises an error for certain operations\n with booleans.\ndiff --git a/pandas/core/ops/invalid.py b/pandas/core/ops/invalid.py\nindex cc4a1f11edd2b..4d9cf3ceac4de 100644\n--- a/pandas/core/ops/invalid.py\n+++ b/pandas/core/ops/invalid.py\n@@ -48,7 +48,7 @@ def make_invalid_op(name: str):\n invalid_op : function\n \"\"\"\n \n- def invalid_op(self, other=None):\n+ def invalid_op(self, other=None) -> None:\n typ = type(self).__name__\n raise TypeError(f\"cannot perform {name} with this index type: {typ}\")\n \ndiff --git a/pandas/core/ops/mask_ops.py b/pandas/core/ops/mask_ops.py\nindex 57bacba0d4bee..adc1f63c568bf 100644\n--- a/pandas/core/ops/mask_ops.py\n+++ b/pandas/core/ops/mask_ops.py\n@@ -184,6 +184,6 @@ def kleene_and(\n return result, mask\n \n \n-def raise_for_nan(value, method: str):\n+def raise_for_nan(value, method: str) -> None:\n if lib.is_float(value) and np.isnan(value):\n raise ValueError(f\"Cannot perform logical '{method}' with floating NaN\")\ndiff --git a/pandas/core/ops/methods.py b/pandas/core/ops/methods.py\nindex df22919ed19f1..cfb1649c14734 100644\n--- a/pandas/core/ops/methods.py\n+++ b/pandas/core/ops/methods.py\n@@ -43,7 +43,7 @@ def _get_method_wrappers(cls):\n return arith_flex, comp_flex\n \n \n-def add_flex_arithmetic_methods(cls):\n+def add_flex_arithmetic_methods(cls) -> None:\n \"\"\"\n Adds the full suite of flex arithmetic methods (``pow``, ``mul``, ``add``)\n to the class.\n@@ -117,6 +117,6 @@ def _create_methods(cls, arith_method, comp_method):\n return new_methods\n \n \n-def _add_methods(cls, new_methods):\n+def _add_methods(cls, new_methods) -> None:\n for name, method in new_methods.items():\n setattr(cls, name, method)\ndiff --git a/pandas/core/reshape/concat.py b/pandas/core/reshape/concat.py\nindex 523cd56db3e0a..a7cd0479b4d32 100644\n--- a/pandas/core/reshape/concat.py\n+++ b/pandas/core/reshape/concat.py\n@@ -697,7 +697,7 @@ def _get_concat_axis(self) -> Index:\n \n return concat_axis\n \n- def _maybe_check_integrity(self, concat_index: Index):\n+ def _maybe_check_integrity(self, concat_index: Index) -> None:\n if self.verify_integrity:\n if not concat_index.is_unique:\n overlap = concat_index[concat_index.duplicated()].unique()\ndiff --git a/pandas/core/reshape/encoding.py b/pandas/core/reshape/encoding.py\nindex f0500ec142955..c0a43d4766fa0 100644\n--- a/pandas/core/reshape/encoding.py\n+++ b/pandas/core/reshape/encoding.py\n@@ -143,7 +143,7 @@ def get_dummies(\n data_to_encode = data[columns]\n \n # validate prefixes and separator to avoid silently dropping cols\n- def check_len(item, name):\n+ def check_len(item, name) -> None:\n \n if is_list_like(item):\n if not len(item) == data_to_encode.shape[1]:\ndiff --git a/pandas/core/reshape/reshape.py b/pandas/core/reshape/reshape.py\nindex b4e944861f1bc..e083de96f892f 100644\n--- a/pandas/core/reshape/reshape.py\n+++ b/pandas/core/reshape/reshape.py\n@@ -162,7 +162,7 @@ def _make_sorted_values(self, values: np.ndarray) -> np.ndarray:\n sorted_values = algos.take_nd(values, indexer, axis=0)\n return sorted_values\n \n- def _make_selectors(self):\n+ def _make_selectors(self) -> None:\n new_levels = self.new_index_levels\n \n # make the mask\ndiff --git a/pandas/core/series.py b/pandas/core/series.py\nindex 06815348fe4b9..606664c88d900 100644\n--- a/pandas/core/series.py\n+++ b/pandas/core/series.py\n@@ -1165,7 +1165,7 @@ def _set_with_engine(self, key, value) -> None:\n # this is equivalent to self._values[key] = value\n self._mgr.setitem_inplace(loc, value)\n \n- def _set_with(self, key, value):\n+ def _set_with(self, key, value) -> None:\n # We got here via exception-handling off of InvalidIndexError, so\n # key should always be listlike at this point.\n assert not isinstance(key, tuple)\n@@ -1203,7 +1203,7 @@ def _set_values(self, key, value) -> None:\n self._mgr = self._mgr.setitem(indexer=key, value=value)\n self._maybe_update_cacher()\n \n- def _set_value(self, label, value, takeable: bool = False):\n+ def _set_value(self, label, value, takeable: bool = False) -> None:\n \"\"\"\n Quickly set single value at passed label.\n \ndiff --git a/pandas/core/window/ewm.py b/pandas/core/window/ewm.py\nindex a153761f377b3..e955e4e228476 100644\n--- a/pandas/core/window/ewm.py\n+++ b/pandas/core/window/ewm.py\n@@ -948,7 +948,7 @@ def __init__(\n else:\n raise ValueError(\"'numba' is the only supported engine\")\n \n- def reset(self):\n+ def reset(self) -> None:\n \"\"\"\n Reset the state captured by `update` calls.\n \"\"\"\ndiff --git a/pandas/core/window/online.py b/pandas/core/window/online.py\nindex 2ef06732f9800..bb973f05687e2 100644\n--- a/pandas/core/window/online.py\n+++ b/pandas/core/window/online.py\n@@ -112,6 +112,6 @@ def run_ewm(self, weighted_avg, deltas, min_periods, ewm_func):\n self.last_ewm = result[-1]\n return result\n \n- def reset(self):\n+ def reset(self) -> None:\n self.old_wt = np.ones(self.shape[self.axis - 1])\n self.last_ewm = None\ndiff --git a/pandas/core/window/rolling.py b/pandas/core/window/rolling.py\nindex b45f43adbe952..45170c26fb148 100644\n--- a/pandas/core/window/rolling.py\n+++ b/pandas/core/window/rolling.py\n@@ -1154,7 +1154,7 @@ class Window(BaseWindow):\n \"method\",\n ]\n \n- def _validate(self):\n+ def _validate(self) -> None:\n super()._validate()\n \n if not isinstance(self.win_type, str):\n@@ -1817,7 +1817,7 @@ class Rolling(RollingAndExpandingMixin):\n \"method\",\n ]\n \n- def _validate(self):\n+ def _validate(self) -> None:\n super()._validate()\n \n # we allow rolling on a datetimelike index\n@@ -1862,7 +1862,7 @@ def _validate(self):\n elif not is_integer(self.window) or self.window < 0:\n raise ValueError(\"window must be an integer 0 or greater\")\n \n- def _validate_datetimelike_monotonic(self):\n+ def _validate_datetimelike_monotonic(self) -> None:\n \"\"\"\n Validate self._on is monotonic (increasing or decreasing) and has\n no NaT values for frequency windows.\n@@ -1872,7 +1872,7 @@ def _validate_datetimelike_monotonic(self):\n if not (self._on.is_monotonic_increasing or self._on.is_monotonic_decreasing):\n self._raise_monotonic_error(\"values must be monotonic\")\n \n- def _raise_monotonic_error(self, msg: str):\n+ def _raise_monotonic_error(self, msg: str) -> None:\n on = self.on\n if on is None:\n if self.axis == 0:\n@@ -2865,7 +2865,7 @@ def _get_window_indexer(self) -> GroupbyIndexer:\n )\n return window_indexer\n \n- def _validate_datetimelike_monotonic(self):\n+ def _validate_datetimelike_monotonic(self) -> None:\n \"\"\"\n Validate that each group in self._on is monotonic\n \"\"\"\n"},"body":{"kind":"string","value":"- [ ] closes #xxxx (Replace xxxx with the Github issue number)\r\n- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature\r\n- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).\r\n- [ ] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.\r\n- [ ] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.\r\n\r\nvia https://github.com/MarcoGorelli/add-obvious-return-none - adding `-> None` where possible so at least those functions will be type-checked\r\n\r\nthere's gonna be a tonne of CI failures so opening as draft for now"},"url":{"kind":"string","value":"https://api.github.com/repos/pandas-dev/pandas/pulls/47497"},"created_at":{"kind":"string","value":"2022-06-24T17:59:18Z"},"closed_at":{"kind":"string","value":"2022-07-28T07:28:19Z"},"merged_at":{"kind":"null"},"updated_at":{"kind":"string","value":"2022-08-20T16:45:19Z"}}},{"rowIdx":13098,"cells":{"title":{"kind":"string","value":"BUG: read_excel not forward filling index columns when no names are given"},"diff":{"kind":"string","value":"diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst\nindex 6fc1ec9c6ff90..a86436fac3487 100644\n--- a/doc/source/whatsnew/v1.5.0.rst\n+++ b/doc/source/whatsnew/v1.5.0.rst\n@@ -934,6 +934,7 @@ I/O\n - Bug in :func:`read_parquet` when ``engine=\"fastparquet\"`` where the file was not closed on error (:issue:`46555`)\n - :meth:`to_html` now excludes the ``border`` attribute from ``<table>`` elements when ``border`` keyword is set to ``False``.\n - Bug in :func:`read_sas` with certain types of compressed SAS7BDAT files (:issue:`35545`)\n+- Bug in :func:`read_excel` not forward filling :class:`MultiIndex` when no names were given (:issue:`47487`)\n - Bug in :func:`read_sas` returned ``None`` rather than an empty DataFrame for SAS7BDAT files with zero rows (:issue:`18198`)\n - Bug in :class:`StataWriter` where value labels were always written with default encoding (:issue:`46750`)\n - Bug in :class:`StataWriterUTF8` where some valid characters were removed from variable names (:issue:`47276`)\ndiff --git a/pandas/io/excel/_base.py b/pandas/io/excel/_base.py\nindex 0c4268626099a..a0abddc82e6c8 100644\n--- a/pandas/io/excel/_base.py\n+++ b/pandas/io/excel/_base.py\n@@ -788,9 +788,27 @@ def parse(\n \n # If there is a MultiIndex header and an index then there is also\n # a row containing just the index name(s)\n- has_index_names = (\n- is_list_header and not is_len_one_list_header and index_col is not None\n- )\n+ has_index_names = False\n+ if is_list_header and not is_len_one_list_header and index_col is not None:\n+\n+ index_col_list: Sequence[int]\n+ if isinstance(index_col, int):\n+ index_col_list = [index_col]\n+ else:\n+ assert isinstance(index_col, Sequence)\n+ index_col_list = index_col\n+\n+ # We have to handle mi without names. If any of the entries in the data\n+ # columns are not empty, this is a regular row\n+ assert isinstance(header, Sequence)\n+ if len(header) < len(data):\n+ potential_index_names = data[len(header)]\n+ potential_data = [\n+ x\n+ for i, x in enumerate(potential_index_names)\n+ if not control_row[i] and i not in index_col_list\n+ ]\n+ has_index_names = all(x == \"\" or x is None for x in potential_data)\n \n if is_list_like(index_col):\n # Forward fill values for MultiIndex index.\ndiff --git a/pandas/tests/io/data/excel/multiindex_no_index_names.xlsx b/pandas/tests/io/data/excel/multiindex_no_index_names.xlsx\nnew file mode 100755\nindex 0000000000000..3913ffce5befb\nBinary files /dev/null and b/pandas/tests/io/data/excel/multiindex_no_index_names.xlsx differ\ndiff --git a/pandas/tests/io/excel/test_openpyxl.py b/pandas/tests/io/excel/test_openpyxl.py\nindex ea9a45cf829f2..3b122c8572751 100644\n--- a/pandas/tests/io/excel/test_openpyxl.py\n+++ b/pandas/tests/io/excel/test_openpyxl.py\n@@ -396,3 +396,17 @@ def test_ints_spelled_with_decimals(datapath, ext):\n result = pd.read_excel(path)\n expected = DataFrame(range(2, 12), columns=[1])\n tm.assert_frame_equal(result, expected)\n+\n+\n+def test_read_multiindex_header_no_index_names(datapath, ext):\n+ # GH#47487\n+ path = datapath(\"io\", \"data\", \"excel\", f\"multiindex_no_index_names{ext}\")\n+ result = pd.read_excel(path, index_col=[0, 1, 2], header=[0, 1, 2])\n+ expected = DataFrame(\n+ [[np.nan, \"x\", \"x\", \"x\"], [\"x\", np.nan, np.nan, np.nan]],\n+ columns=pd.MultiIndex.from_tuples(\n+ [(\"X\", \"Y\", \"A1\"), (\"X\", \"Y\", \"A2\"), (\"XX\", \"YY\", \"B1\"), (\"XX\", \"YY\", \"B2\")]\n+ ),\n+ index=pd.MultiIndex.from_tuples([(\"A\", \"AA\", \"AAA\"), (\"A\", \"BB\", \"BBB\")]),\n+ )\n+ tm.assert_frame_equal(result, expected)\n"},"body":{"kind":"string","value":"- [x] closes #47487 (Replace xxxx with the Github issue number)\r\n- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature\r\n- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).\r\n- [x] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.\r\n- [x] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.\r\n\r\n\r\nThe prevoious has_index_name routine was too simple. This version is aligned with the TextReader version that is used a few lines below"},"url":{"kind":"string","value":"https://api.github.com/repos/pandas-dev/pandas/pulls/47496"},"created_at":{"kind":"string","value":"2022-06-24T13:05:35Z"},"closed_at":{"kind":"string","value":"2022-07-03T15:27:34Z"},"merged_at":{"kind":"string","value":"2022-07-03T15:27:34Z"},"updated_at":{"kind":"string","value":"2022-07-03T17:10:01Z"}}},{"rowIdx":13099,"cells":{"title":{"kind":"string","value":"BUG: read_csv ignoring non existing header rows for python engine"},"diff":{"kind":"string","value":"diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst\nindex 35594fbc8fb8a..5629ebf604697 100644\n--- a/doc/source/whatsnew/v1.5.0.rst\n+++ b/doc/source/whatsnew/v1.5.0.rst\n@@ -873,6 +873,7 @@ I/O\n - Bug in :func:`read_csv` interpreting second row as :class:`Index` names even when ``index_col=False`` (:issue:`46569`)\n - Bug in :func:`read_parquet` when ``engine=\"pyarrow\"`` which caused partial write to disk when column of unsupported datatype was passed (:issue:`44914`)\n - Bug in :func:`DataFrame.to_excel` and :class:`ExcelWriter` would raise when writing an empty DataFrame to a ``.ods`` file (:issue:`45793`)\n+- Bug in :func:`read_csv` ignoring non-existing header row for ``engine=\"python\"`` (:issue:`47400`)\n - Bug in :func:`read_excel` raising uncontrolled ``IndexError`` when ``header`` references non-existing rows (:issue:`43143`)\n - Bug in :func:`read_html` where elements surrounding ``<br>`` were joined without a space between them (:issue:`29528`)\n - Bug in :func:`read_csv` when data is longer than header leading to issues with callables in ``usecols`` expecting strings (:issue:`46997`)\ndiff --git a/pandas/io/parsers/python_parser.py b/pandas/io/parsers/python_parser.py\nindex 2bf66923ddd60..ec953c9df036c 100644\n--- a/pandas/io/parsers/python_parser.py\n+++ b/pandas/io/parsers/python_parser.py\n@@ -379,10 +379,16 @@ def _infer_columns(\n line = self._next_line()\n \n except StopIteration as err:\n- if self.line_pos < hr:\n+ if 0 < self.line_pos <= hr and (\n+ not have_mi_columns or hr != header[-1]\n+ ):\n+ # If no rows we want to raise a different message and if\n+ # we have mi columns, the last line is not part of the header\n+ joi = list(map(str, header[:-1] if have_mi_columns else header))\n+ msg = f\"[{','.join(joi)}], len of {len(joi)}, \"\n raise ValueError(\n- f\"Passed header={hr} but only {self.line_pos + 1} lines in \"\n- \"file\"\n+ f\"Passed header={msg}\"\n+ f\"but only {self.line_pos} lines in file\"\n ) from err\n \n # We have an empty file, so check\ndiff --git a/pandas/tests/io/parser/test_header.py b/pandas/tests/io/parser/test_header.py\nindex 3fc23525df89e..4ded70db8bae7 100644\n--- a/pandas/tests/io/parser/test_header.py\n+++ b/pandas/tests/io/parser/test_header.py\n@@ -666,3 +666,15 @@ def test_header_none_and_on_bad_lines_skip(all_parsers):\n )\n expected = DataFrame({\"a\": [\"x\", \"z\"], \"b\": [1, 3]})\n tm.assert_frame_equal(result, expected)\n+\n+\n+@skip_pyarrow\n+def test_header_missing_rows(all_parsers):\n+ # GH#47400\n+ parser = all_parsers\n+ data = \"\"\"a,b\n+1,2\n+\"\"\"\n+ msg = r\"Passed header=\\[0,1,2\\], len of 3, but only 2 lines in file\"\n+ with pytest.raises(ValueError, match=msg):\n+ parser.read_csv(StringIO(data), header=[0, 1, 2])\n"},"body":{"kind":"string","value":"- [x] closes #47400 (Replace xxxx with the Github issue number)\r\n- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature\r\n- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).\r\n- [x] Added [type annotations](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#type-hints) to new arguments/methods/functions.\r\n- [x] Added an entry in the latest `doc/source/whatsnew/vX.X.X.rst` file if fixing a bug or adding a new feature.\r\n\r\nInitially, I thought this would be a case for deprecation, but this was simply a bug and was supposed to work before.\r\nAlso, I aligned the error message of the python parser with the c parser\r\n"},"url":{"kind":"string","value":"https://api.github.com/repos/pandas-dev/pandas/pulls/47493"},"created_at":{"kind":"string","value":"2022-06-24T10:21:23Z"},"closed_at":{"kind":"string","value":"2022-06-24T21:10:11Z"},"merged_at":{"kind":"string","value":"2022-06-24T21:10:11Z"},"updated_at":{"kind":"string","value":"2022-06-25T14:23:34Z"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":130,"numItemsPerPage":100,"numTotalItems":56742,"offset":13000,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sInJlcG9JZHMiOlsiNjYzMDkyMzhkMzc5ZDhmYzljY2I0YzcyIl0sImlhdCI6MTc5MjI1MzIzMSwianRpIjoiNmVlM2Q1N2QtNDZiYy00MTk3LTgxMDEtYjk3NmUzYTc4OTg4Iiwic3ViIjoiL2RhdGFzZXRzL1NhbW9lZC9QUkdlbiIsImV4cCI6MTc5MjI1NjgzMSwiaXNzIjoiaHR0cHM6Ly9odWdnaW5nZmFjZS5jbyJ9.P6u3h_ikuuuIa4GXYQNAL3FsVlUc-6O0XdfAIgrSvD6v5NYajaDU-aun0gjP_hoSARs2AN1jkD_zOIvbzrVZCg","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"validation","numRows":56742,"numBytesParquet":285004812}]},"discussionsStats":{"closed":0,"open":1,"total":1},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
title stringlengths 1 185 | diff stringlengths 0 32.2M | body stringlengths 0 123k ⌀ | url stringlengths 57 58 | created_at stringlengths 20 20 | closed_at stringlengths 20 20 | merged_at stringlengths 20 20 ⌀ | updated_at stringlengths 20 20 |
|---|---|---|---|---|---|---|---|
Fixed mypy errors in frequencies.py | diff --git a/pandas/tseries/frequencies.py b/pandas/tseries/frequencies.py
index 7ad68a812c2e2..a4fe2161983b6 100644
--- a/pandas/tseries/frequencies.py
+++ b/pandas/tseries/frequencies.py
@@ -394,11 +394,11 @@ def _get_annual_rule(self) -> str | None:
return None
pos_check = self.month_position... | - [ ] xref #37715 (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/cont... | https://api.github.com/repos/pandas-dev/pandas/pulls/47644 | 2022-07-08T18:57:52Z | 2022-07-08T22:13:05Z | 2022-07-08T22:13:05Z | 2022-07-08T22:14:41Z |
ENH: add result_names argument to DataFrame.compare #44354 | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index b081f743f9b0b..22a5f2a08362f 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -278,6 +278,7 @@ Other enhancements
- :meth:`DatetimeIndex.astype` now supports casting timezone-naive indexes to ``datetim... | This is following up on the pull request #44365
- [X] closes #44354 (Replace xxxx with the Github issue number)
- [X] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [X] All [code checks passed](https:/... | https://api.github.com/repos/pandas-dev/pandas/pulls/47643 | 2022-07-08T17:48:16Z | 2022-07-16T14:29:38Z | 2022-07-16T14:29:38Z | 2022-07-16T14:29:50Z |
ENH: add suffixes argument to DataFrame.compare #44354 | This is following up on the pull request #44365
- [X] closes #xxxx (Replace xxxx with the Github issue number)
- [X] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [X] All [code checks passed](https://... | https://api.github.com/repos/pandas-dev/pandas/pulls/47642 | 2022-07-08T17:37:54Z | 2022-07-08T17:44:57Z | null | 2022-07-08T17:46:10Z | |
POC/ENH: Timedelta min/max/resolution support non-nano | diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index 5fd3e33808800..fef2a317a4f26 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -950,14 +950,18 @@ cdef _timedelta_from_value_and_reso(int64_t value, NPY_DATETIMEUNIT reso):
cdef:
... | null | https://api.github.com/repos/pandas-dev/pandas/pulls/47641 | 2022-07-08T15:56:23Z | 2022-07-08T17:49:27Z | 2022-07-08T17:49:27Z | 2022-07-11T17:06:46Z |
TST: adding test for multiindex nunique raising not implemnted error | diff --git a/pandas/tests/indexing/multiindex/test_multiindex.py b/pandas/tests/indexing/multiindex/test_multiindex.py
index 193f3eb1a590f..08e15545cb998 100644
--- a/pandas/tests/indexing/multiindex/test_multiindex.py
+++ b/pandas/tests/indexing/multiindex/test_multiindex.py
@@ -214,6 +214,11 @@ def test_subtracting_t... | - [x] closes #34019
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
| https://api.github.com/repos/pandas-dev/pandas/pulls/47638 | 2022-07-08T10:17:59Z | 2022-07-08T17:04:24Z | 2022-07-08T17:04:24Z | 2022-10-20T08:44:45Z |
DEPR: Remove deprecation from private class IntervalTree | diff --git a/pandas/_libs/intervaltree.pxi.in b/pandas/_libs/intervaltree.pxi.in
index 1a6106173e58e..8bf1a53d56dfb 100644
--- a/pandas/_libs/intervaltree.pxi.in
+++ b/pandas/_libs/intervaltree.pxi.in
@@ -8,8 +8,6 @@ import warnings
from pandas._libs import lib
from pandas._libs.algos import is_monotonic
-from pand... | this is private, so no need to deprecate | https://api.github.com/repos/pandas-dev/pandas/pulls/47637 | 2022-07-08T10:17:25Z | 2022-07-08T17:06:05Z | 2022-07-08T17:06:05Z | 2022-07-08T19:53:25Z |
DEPR: Deprecate set_closed and add set_incluive | diff --git a/doc/redirects.csv b/doc/redirects.csv
index 173e670e30f0e..90ddf6c4dc582 100644
--- a/doc/redirects.csv
+++ b/doc/redirects.csv
@@ -761,6 +761,7 @@ generated/pandas.IntervalIndex.mid,../reference/api/pandas.IntervalIndex.mid
generated/pandas.IntervalIndex.overlaps,../reference/api/pandas.IntervalIndex.ove... | Deprecatets set closed for ser_inclusive to keep consistency
| https://api.github.com/repos/pandas-dev/pandas/pulls/47636 | 2022-07-08T10:16:21Z | 2022-07-08T22:16:03Z | 2022-07-08T22:16:03Z | 2022-07-09T02:11:43Z |
DOC #45443 edited the documentation of where/mask functions | diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index ba3474a2513fb..489ad1e3bf5c2 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -9614,7 +9614,8 @@ def where(
The {name} method is an application of the if-then idiom. For each
element in the calling DataFrame, if ``co... | - [X] closes #45443 (Replace xxxx with the Github issue number)
- [X] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
| https://api.github.com/repos/pandas-dev/pandas/pulls/47635 | 2022-07-08T07:41:27Z | 2022-07-08T10:22:57Z | null | 2022-07-08T10:22:57Z |
DOC #45443 edited the documentation of where/mask functions | diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index ba3474a2513fb..489ad1e3bf5c2 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -9614,7 +9614,8 @@ def where(
The {name} method is an application of the if-then idiom. For each
element in the calling DataFrame, if ``co... | - [X] closes #47626
- [X] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
| https://api.github.com/repos/pandas-dev/pandas/pulls/47634 | 2022-07-08T07:38:08Z | 2022-07-08T07:40:09Z | null | 2022-07-08T07:40:09Z |
BUG: Series.str.zfill() behaves differently than str.zfill() from standard library | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index c85a087835b80..cbb1d306f9927 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -530,6 +530,7 @@ Conversion
Strings
^^^^^^^
- Bug in :meth:`str.startswith` and :meth:`str.endswith` when using other ser... | - [ ] closes #20868 (Replace xxxx with the Github issue number)
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/co... | https://api.github.com/repos/pandas-dev/pandas/pulls/47633 | 2022-07-08T07:35:44Z | 2022-07-10T00:15:25Z | 2022-07-10T00:15:25Z | 2022-07-10T01:24:04Z |
DOC: fixing override of built-in functions in docs | diff --git a/doc/source/getting_started/comparison/comparison_with_r.rst b/doc/source/getting_started/comparison/comparison_with_r.rst
index f91f4218c3429..dad6edb25219d 100644
--- a/doc/source/getting_started/comparison/comparison_with_r.rst
+++ b/doc/source/getting_started/comparison/comparison_with_r.rst
@@ -133,8 +... | - [x] closes #47606
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [... | https://api.github.com/repos/pandas-dev/pandas/pulls/47632 | 2022-07-08T02:53:06Z | 2022-07-08T16:26:04Z | null | 2022-07-08T16:26:05Z |
DOC: avoid overriding Python built-in functions | diff --git a/doc/source/user_guide/groupby.rst b/doc/source/user_guide/groupby.rst
index ba3fb17cc8764..5d8ef7ce02097 100644
--- a/doc/source/user_guide/groupby.rst
+++ b/doc/source/user_guide/groupby.rst
@@ -839,10 +839,10 @@ Alternatively, the built-in methods could be used to produce the same outputs.
.. ipython:... | - [x] closes #47606
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ... | https://api.github.com/repos/pandas-dev/pandas/pulls/47631 | 2022-07-08T02:49:59Z | 2022-07-08T16:23:11Z | 2022-07-08T16:23:11Z | 2022-07-12T01:33:54Z |
BUG: using read_xml with iterparse and names will ignore duplicate values | diff --git a/pandas/io/xml.py b/pandas/io/xml.py
index 95fac0c739895..9b6eb31dafc07 100644
--- a/pandas/io/xml.py
+++ b/pandas/io/xml.py
@@ -342,7 +342,7 @@ def _iterparse_nodes(self, iterparse: Callable) -> list[dict[str, str | None]]:
for col, nm in zip(self.iterparse[row_node], self.names):
... | - [X] closes #47483
- [X] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [X] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ]... | https://api.github.com/repos/pandas-dev/pandas/pulls/47630 | 2022-07-08T01:28:53Z | 2022-07-08T16:19:58Z | 2022-07-08T16:19:57Z | 2022-07-09T00:28:08Z |
Test for nested series equality #22400 | diff --git a/pandas/tests/util/test_assert_series_equal.py b/pandas/tests/util/test_assert_series_equal.py
index 2209bed67325c..963af81bcb6a5 100644
--- a/pandas/tests/util/test_assert_series_equal.py
+++ b/pandas/tests/util/test_assert_series_equal.py
@@ -1,3 +1,4 @@
+import numpy as np
import pytest
from pandas.c... | - [ ] closes #22400 (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/co... | https://api.github.com/repos/pandas-dev/pandas/pulls/47627 | 2022-07-07T20:25:49Z | 2022-07-07T22:27:46Z | 2022-07-07T22:27:45Z | 2022-07-07T22:27:55Z |
"DOC #45443 edited the documentation of where/mask functions" | diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index ba3474a2513fb..8089fc58db07d 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -9614,7 +9614,9 @@ def where(
The {name} method is an application of the if-then idiom. For each
element in the calling DataFrame, if ``co... | - [X] closes #45443
- [X] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
| https://api.github.com/repos/pandas-dev/pandas/pulls/47626 | 2022-07-07T17:58:14Z | 2022-07-08T22:17:31Z | 2022-07-08T22:17:31Z | 2022-07-08T22:17:45Z |
ENH: Make categories setitem error more readable | diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index 70699c45e0c36..0a93ebf82c869 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -1474,10 +1474,11 @@ def _validate_scalar(self, fill_value):
elif fill_value in self.categories:
... | Closes #46646 | https://api.github.com/repos/pandas-dev/pandas/pulls/47624 | 2022-07-07T12:23:48Z | 2022-08-15T16:22:51Z | null | 2022-08-15T16:22:52Z |
BUG: boolean indexer with NA raising when reindex is necessary | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 0b450fab53137..62a99ce3cae44 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -885,6 +885,7 @@ Indexing
- Bug when setting a value too large for a :class:`Series` dtype failing to coerce to a common ty... | - [x] closes #46551 (Replace xxxx with the Github issue number)
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/co... | https://api.github.com/repos/pandas-dev/pandas/pulls/47623 | 2022-07-07T11:47:26Z | 2022-07-08T22:53:53Z | 2022-07-08T22:53:53Z | 2022-07-09T02:12:23Z |
WARN: Don't show FutureWarning when enlarging df with iloc | diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index 665333d0d7b4f..adc4b8c003515 100644
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -2004,11 +2004,16 @@ def _setitem_single_column(self, loc: int, value, plane_indexer):
if (
isinstance(new_values, np.ndar... | - [x] xref #47381 (Replace xxxx with the Github issue number)
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/cont... | https://api.github.com/repos/pandas-dev/pandas/pulls/47621 | 2022-07-07T06:34:31Z | 2022-07-07T16:37:28Z | 2022-07-07T16:37:28Z | 2022-07-08T20:07:47Z |
Equal test | diff --git a/pandas/tests/util/test_assert_series_equal.py b/pandas/tests/util/test_assert_series_equal.py
index 2209bed67325c..4e5e45b315fc1 100644
--- a/pandas/tests/util/test_assert_series_equal.py
+++ b/pandas/tests/util/test_assert_series_equal.py
@@ -382,3 +382,21 @@ def test_assert_series_equal_identical_na(null... | - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/con... | https://api.github.com/repos/pandas-dev/pandas/pulls/47620 | 2022-07-07T00:42:53Z | 2022-07-07T05:46:00Z | null | 2022-07-07T05:46:01Z |
BUG: Return Float64 for read_parquet(use_nullable_dtypes=True) | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 0b450fab53137..c70acc0a0b18c 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -948,7 +948,7 @@ I/O
- Bug in :func:`read_sas` with RLE-compressed SAS7BDAT files that contain 0x40 control bytes (:issue:`... | - [x] closes #45694 (Replace xxxx with the Github issue number)
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/co... | https://api.github.com/repos/pandas-dev/pandas/pulls/47619 | 2022-07-06T22:23:23Z | 2022-07-07T16:10:11Z | 2022-07-07T16:10:10Z | 2022-07-07T16:10:14Z |
TYP: more return annotations in core/ | diff --git a/pandas/_testing/__init__.py b/pandas/_testing/__init__.py
index 0fcea111716ec..5e90eae27f981 100644
--- a/pandas/_testing/__init__.py
+++ b/pandas/_testing/__init__.py
@@ -529,7 +529,7 @@ def getMixedTypeDict():
return index, data
-def makeMixedDataFrame():
+def makeMixedDataFrame() -> DataFrame:
... | Probably the last big PR related to #47521 There are many more missing return annotations but they should be addressed in smaller PRs (they are either difficult to type or lead to many ignore comments). | https://api.github.com/repos/pandas-dev/pandas/pulls/47618 | 2022-07-06T21:59:25Z | 2022-07-07T16:45:19Z | 2022-07-07T16:45:19Z | 2022-09-21T15:28:31Z |
DOC: Fixed pandas capitalization | diff --git a/RELEASE.md b/RELEASE.md
index 42cb82dfcf020..344a097a3e81e 100644
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -1,6 +1,6 @@
Release Notes
=============
-The list of changes to Pandas between each release can be found
+The list of changes to pandas between each release can be found
[here](https://pandas.pydata... | Fixed wrong capitalization of "pandas" in RELEASE.md.
| https://api.github.com/repos/pandas-dev/pandas/pulls/47617 | 2022-07-06T20:59:23Z | 2022-07-06T21:11:12Z | 2022-07-06T21:11:11Z | 2022-07-06T21:11:18Z |
TST: Added test for strides in column major Dataframes stored in HDFS… | diff --git a/pandas/tests/io/pytables/test_store.py b/pandas/tests/io/pytables/test_store.py
index 8a933f4981ff3..3a6f699cce94e 100644
--- a/pandas/tests/io/pytables/test_store.py
+++ b/pandas/tests/io/pytables/test_store.py
@@ -1019,3 +1019,11 @@ def test_hdfstore_iteritems_deprecated(setup_path):
hdf.put... | …tore
- [x] closes #22073.
- [x] Tests added and passed.
- [x] All code checks passed.
Added test for column-major DataFrames stored in HDFStore which were incorrectly returned as row-major.
Tests and linter pass locally. | https://api.github.com/repos/pandas-dev/pandas/pulls/47616 | 2022-07-06T20:52:14Z | 2022-07-07T00:10:56Z | 2022-07-07T00:10:56Z | 2022-07-07T05:46:09Z |
Create codeql-analysis.yml | diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
new file mode 100644
index 0000000000000..2ca08a1c1514c
--- /dev/null
+++ b/.github/workflows/codeql-analysis.yml
@@ -0,0 +1,72 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it t... | - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/con... | https://api.github.com/repos/pandas-dev/pandas/pulls/47615 | 2022-07-06T17:31:33Z | 2022-07-06T21:59:53Z | null | 2022-07-06T21:59:59Z |
Fix Period not using freq when using same base-freq. | diff --git a/pandas/_libs/tslibs/period.pyx b/pandas/_libs/tslibs/period.pyx
index e187df6d6f627..9072b90e3e7f8 100644
--- a/pandas/_libs/tslibs/period.pyx
+++ b/pandas/_libs/tslibs/period.pyx
@@ -2552,12 +2552,11 @@ class Period(_Period):
hour, minute, second, freq)
... | - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/con... | https://api.github.com/repos/pandas-dev/pandas/pulls/47613 | 2022-07-06T16:07:32Z | 2022-09-01T21:25:30Z | null | 2022-09-01T21:25:30Z |
CLN: Add tets and fix docstring for concat with sort=True and outer join | diff --git a/pandas/core/indexes/api.py b/pandas/core/indexes/api.py
index 6820b7b5360a5..b4f47f70c5a84 100644
--- a/pandas/core/indexes/api.py
+++ b/pandas/core/indexes/api.py
@@ -233,6 +233,7 @@ def _unique_indices(inds, dtype) -> Index:
Parameters
----------
inds : list of Index or list ob... | cc @simonjayhawkins
Added a couple of tests and fixed the docstring | https://api.github.com/repos/pandas-dev/pandas/pulls/47612 | 2022-07-06T14:45:25Z | 2022-07-07T17:04:55Z | 2022-07-07T17:04:55Z | 2022-07-08T20:07:04Z |
DOC: fix shared compression_options and decompression_options | diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 3967c3df6b7cb..76a473dad79a4 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -3296,7 +3296,7 @@ def to_latex(
@final
@doc(
storage_options=_shared_docs["storage_options"],
- compression_options=_shared_docs[... | Both compression_options and decompression_options made the same
reference to zstandard.ZstdDecompressor however compression uses
zstandard.ZstdCompressor and so the documentation for
compression_options should refer to this class instead
The shared doc strings compression_options and decompression_options
requi... | https://api.github.com/repos/pandas-dev/pandas/pulls/47609 | 2022-07-06T10:55:53Z | 2022-07-06T16:45:15Z | 2022-07-06T16:45:15Z | 2022-07-06T16:45:22Z |
BUG: df.groupby().resample()[[cols]] without key columns raise KeyError | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 0b450fab53137..5b07fc31287e5 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -996,6 +996,8 @@ Groupby/resample/rolling
- Bug in :meth:`.DataFrameGroupBy.describe` and :meth:`.SeriesGroupBy.describe` p... | - [x] closes #47362
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ]... | https://api.github.com/repos/pandas-dev/pandas/pulls/47605 | 2022-07-06T04:44:26Z | 2022-07-11T21:00:02Z | 2022-07-11T21:00:02Z | 2022-07-12T02:00:41Z |
Add test for unique aggregation returning different dtypes | diff --git a/pandas/tests/apply/test_frame_apply.py b/pandas/tests/apply/test_frame_apply.py
index 72a9d8723d34c..1ef0865fff552 100644
--- a/pandas/tests/apply/test_frame_apply.py
+++ b/pandas/tests/apply/test_frame_apply.py
@@ -1585,3 +1585,21 @@ def test_apply_on_empty_dataframe():
result = df.head(0).apply(lamb... | - [ ] closes #22558 (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/co... | https://api.github.com/repos/pandas-dev/pandas/pulls/47603 | 2022-07-05T23:16:10Z | 2022-07-26T21:11:05Z | 2022-07-26T21:11:05Z | 2022-07-26T21:11:15Z |
BUG: Make xticks from _quarterly_finder() line up better | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 0b450fab53137..746d58fb6b437 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -970,6 +970,7 @@ Plotting
- Bug in :meth:`DataFrame.plot.scatter` that prevented specifying ``norm`` (:issue:`45809`)
- Th... | When I plot a series of quarterly data that spans more than 11 years, my vertical grid lines get placed a year before where they should, i.e., one year before a year that is divisible by the default annual spacing. Changing one line in the _quarterly_finder() function, from +1 to +1970, fixes this for me. Can anyone pl... | https://api.github.com/repos/pandas-dev/pandas/pulls/47602 | 2022-07-05T21:42:50Z | 2022-07-15T19:20:56Z | 2022-07-15T19:20:56Z | 2022-07-15T19:52:27Z |
ENH/TST: Add TestBaseReshaping tests for ArrowExtensionArray | diff --git a/pandas/tests/extension/test_arrow.py b/pandas/tests/extension/test_arrow.py
index 861cc44310751..7e0792a6010a7 100644
--- a/pandas/tests/extension/test_arrow.py
+++ b/pandas/tests/extension/test_arrow.py
@@ -563,13 +563,209 @@ def test_fillna_frame(self, data_missing, using_array_manager, request):
... | - [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
| https://api.github.com/repos/pandas-dev/pandas/pulls/47601 | 2022-07-05T20:38:37Z | 2022-07-08T13:00:56Z | 2022-07-08T13:00:56Z | 2022-07-08T16:12:16Z |
CI: run flake8-pyi with all the other flake8 plugins | diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index c8123f90ab3a3..bfbca05a66e08 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -49,10 +49,13 @@ repos:
rev: 4.0.1
hooks:
- id: flake8
+ types: [text] # overwrite types: [python]
+ types_or: [python, ... | followup to #47595
@mroeschke | https://api.github.com/repos/pandas-dev/pandas/pulls/47600 | 2022-07-05T18:07:40Z | 2022-07-09T23:01:45Z | null | 2022-07-09T23:01:45Z |
BUG: `pd.period_range` ignores multiple of `start` frequency. | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 0b450fab53137..6b90126f556e0 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -959,6 +959,7 @@ Period
- Bug in adding ``np.timedelta64("NaT", "ns")`` to a :class:`Period` with a timedelta-like freq inc... | Fixes: #47465
- [x] closes #47465
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pr... | https://api.github.com/repos/pandas-dev/pandas/pulls/47598 | 2022-07-05T13:23:43Z | 2022-09-01T21:25:23Z | null | 2022-09-01T21:25:24Z |
Added improvements in to_datetime Error reporting message | diff --git a/pandas/_libs/tslib.pyx b/pandas/_libs/tslib.pyx
index ee3964b892e2e..39c8aab2ce5dc 100644
--- a/pandas/_libs/tslib.pyx
+++ b/pandas/_libs/tslib.pyx
@@ -595,7 +595,7 @@ cpdef array_to_datetime(
continue
elif is_raise:
... | - This PR aims to close 3 related issues -
#16757 ,
#46509 ,
#47495
- Changes description
- For issue #16757 - added more details in error message about field and its position causing the issue in `pandas/_libs/tslib.pyx` in `_array_to_datetime_object` and `array_to_datetime`
- For issue #46509 - ... | https://api.github.com/repos/pandas-dev/pandas/pulls/47597 | 2022-07-05T09:34:43Z | 2022-08-07T06:30:48Z | null | 2022-08-07T06:30:48Z |
CI: flake8-pyi | diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 13e0ecd33359f..8d1e13c1e2212 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -229,3 +229,11 @@ repos:
entry: python scripts/validate_min_versions_in_sync.py
language: python
files: ^(ci/deps/actions-.*-... | null | https://api.github.com/repos/pandas-dev/pandas/pulls/47595 | 2022-07-04T19:48:47Z | 2022-07-05T17:36:45Z | 2022-07-05T17:36:45Z | 2022-09-21T15:28:31Z |
TST: added test for handling repeated keys when using Series.loc with Multiindex | diff --git a/pandas/tests/indexing/multiindex/test_multiindex.py b/pandas/tests/indexing/multiindex/test_multiindex.py
index b88c411636610..193f3eb1a590f 100644
--- a/pandas/tests/indexing/multiindex/test_multiindex.py
+++ b/pandas/tests/indexing/multiindex/test_multiindex.py
@@ -213,3 +213,12 @@ def test_subtracting_t... |
- [x] closes #19414.
- [x] Tests added and passed.
- [x] All code checks passed.
Added test for handling repeated keys when using Series.loc with Multiindex.
Tests and linter pass locally. | https://api.github.com/repos/pandas-dev/pandas/pulls/47594 | 2022-07-04T16:55:42Z | 2022-07-05T17:08:22Z | 2022-07-05T17:08:22Z | 2022-07-05T17:08:29Z |
ENH: Move CSSWarning to error/__init__.py per GH27656 | diff --git a/doc/source/reference/testing.rst b/doc/source/reference/testing.rst
index c3ce267ff9dc7..249c2c56cfe57 100644
--- a/doc/source/reference/testing.rst
+++ b/doc/source/reference/testing.rst
@@ -26,6 +26,7 @@ Exceptions and warnings
errors.AbstractMethodError
errors.AccessorRegistrationWarning
+ e... | - [x] xref #27656. this GitHub issue is being done in multiple parts
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/developme... | https://api.github.com/repos/pandas-dev/pandas/pulls/47591 | 2022-07-03T20:07:01Z | 2022-07-05T17:14:46Z | 2022-07-05T17:14:46Z | 2022-07-05T17:14:54Z |
Backport PR #47474 on branch 1.4.x (BUG: to_sql with method=callable not returning int raising TypeError) | diff --git a/doc/source/whatsnew/v1.4.4.rst b/doc/source/whatsnew/v1.4.4.rst
index 0af25daf0468a..6ee140f59e096 100644
--- a/doc/source/whatsnew/v1.4.4.rst
+++ b/doc/source/whatsnew/v1.4.4.rst
@@ -24,7 +24,7 @@ Fixed regressions
Bug fixes
~~~~~~~~~
- The :class:`errors.FutureWarning` raised when passing arguments (o... | Backport PR #47474: BUG: to_sql with method=callable not returning int raising TypeError | https://api.github.com/repos/pandas-dev/pandas/pulls/47590 | 2022-07-03T15:13:33Z | 2022-07-04T10:19:22Z | 2022-07-04T10:19:22Z | 2022-07-04T10:19:23Z |
TST: added test for to_json when called on numbers exceeding the int64 limit | diff --git a/pandas/tests/io/json/test_pandas.py b/pandas/tests/io/json/test_pandas.py
index eaffbc60ead32..026c3bc68ce34 100644
--- a/pandas/tests/io/json/test_pandas.py
+++ b/pandas/tests/io/json/test_pandas.py
@@ -1908,3 +1908,13 @@ def test_complex_data_tojson(self, data, expected):
# GH41174
resu... |
- [x] closes #21073
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests)
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
Added test for to_json() when called o... | https://api.github.com/repos/pandas-dev/pandas/pulls/47589 | 2022-07-03T14:35:49Z | 2022-07-05T16:43:47Z | 2022-07-05T16:43:46Z | 2022-07-05T16:43:57Z |
CLN: concat union_indexes now respecting sort keyword | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 82ae93ad31763..8dc838a5d61a5 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -9523,7 +9523,6 @@ def _append(
verify_integrity: bool = False,
sort: bool = False,
) -> DataFrame:
- combined_columns = None
... | null | https://api.github.com/repos/pandas-dev/pandas/pulls/47588 | 2022-07-03T12:09:47Z | 2022-07-03T14:14:16Z | 2022-07-03T14:14:16Z | 2022-07-03T17:10:08Z |
TYP: return values in core/*.py | diff --git a/pandas/core/algorithms.py b/pandas/core/algorithms.py
index 7e292f4ccf8cb..159c0bb2e72c0 100644
--- a/pandas/core/algorithms.py
+++ b/pandas/core/algorithms.py
@@ -948,7 +948,7 @@ def value_counts(
# Called once from SparseArray, otherwise could be private
def value_counts_arraylike(
values: np.ndar... | This PR is quite a bit larger since many functions needed overloads. | https://api.github.com/repos/pandas-dev/pandas/pulls/47587 | 2022-07-03T00:36:12Z | 2022-07-06T19:57:07Z | 2022-07-06T19:57:07Z | 2022-09-21T15:28:31Z |
BUG: concat losing columns dtypes for join=outer | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 6fc1ec9c6ff90..2f5c2bb36f405 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -995,6 +995,7 @@ Reshaping
- Bug in :func:`get_dummies` that selected object and categorical dtypes but not string (:issue:... | - [x] closes #47329 (Replace xxxx with the Github issue number)
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/co... | https://api.github.com/repos/pandas-dev/pandas/pulls/47586 | 2022-07-02T23:26:10Z | 2022-07-03T14:25:18Z | 2022-07-03T14:25:18Z | 2022-07-08T13:32:05Z |
BUG: Series map ignoring na_action for dict or series mapper | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 090fea57872c5..16fcb34fdb7d1 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -914,6 +914,7 @@ Missing
^^^^^^^
- Bug in :meth:`Series.fillna` and :meth:`DataFrame.fillna` with ``downcast`` keyword not... | - [x] closes #47527 (Replace xxxx with the Github issue number)
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/co... | https://api.github.com/repos/pandas-dev/pandas/pulls/47585 | 2022-07-02T22:48:26Z | 2022-07-21T17:26:42Z | 2022-07-21T17:26:42Z | 2022-08-01T18:16:18Z |
REF: share DTA/TDA.__init__ | diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index 00dc8b2a4a13b..48de7771cd8d7 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -25,6 +25,7 @@
algos,
lib,
)
+from pandas._libs.arrays import NDArrayBacked
from pandas._libs.ts... | - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/con... | https://api.github.com/repos/pandas-dev/pandas/pulls/47583 | 2022-07-02T15:05:45Z | 2022-07-05T17:19:00Z | 2022-07-05T17:19:00Z | 2022-07-05T18:41:01Z |
BUG: DataFrame.loc not aligning rhs df for single block case | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 6fc1ec9c6ff90..4e22ec263289f 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -882,6 +882,7 @@ Indexing
- Bug in :meth:`Series.__setitem__` when setting ``boolean`` dtype values containing ``NA`` incor... | - [x] closes #47578 (Replace xxxx with the Github issue number)
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/co... | https://api.github.com/repos/pandas-dev/pandas/pulls/47581 | 2022-07-02T11:55:29Z | 2022-07-03T14:18:45Z | 2022-07-03T14:18:45Z | 2022-08-08T13:16:49Z |
ENH: DTI/DTA.astype support non-nano | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 3b40ad8caf372..0b450fab53137 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -275,7 +275,9 @@ Other enhancements
- :class:`.DataError`, :class:`.SpecificationError`, :class:`.SettingWithCopyError`, :c... | - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/con... | https://api.github.com/repos/pandas-dev/pandas/pulls/47579 | 2022-07-02T02:56:02Z | 2022-07-05T20:00:51Z | 2022-07-05T20:00:51Z | 2022-07-05T20:04:52Z |
Adding testcase for quartile performed on a timestamp column group by ( closes #33168 ) | diff --git a/pandas/tests/groupby/test_quantile.py b/pandas/tests/groupby/test_quantile.py
index 20328426a69b2..2b7e71d9619a4 100644
--- a/pandas/tests/groupby/test_quantile.py
+++ b/pandas/tests/groupby/test_quantile.py
@@ -343,3 +343,38 @@ def test_columns_groupby_quantile():
)
tm.assert_frame_equal(resul... | Have added a testcase for quartile performed on a timestamp column group by. This change closes #33168
| https://api.github.com/repos/pandas-dev/pandas/pulls/47575 | 2022-07-01T19:57:41Z | 2022-07-03T14:20:33Z | 2022-07-03T14:20:33Z | 2022-07-03T14:20:37Z |
REF: simplify DTA.__init__ | diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index e3a1d1d0705c4..c019edea5eee0 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -256,7 +256,7 @@ def _scalar_type(self) -> type[Timestamp]:
_freq = None
def __init__(
- self, values... | After this we can share DTA/TDA.`__init__` | https://api.github.com/repos/pandas-dev/pandas/pulls/47574 | 2022-07-01T19:10:36Z | 2022-07-01T22:16:23Z | 2022-07-01T22:16:23Z | 2022-07-01T22:16:36Z |
CLN: Move monotonic check to safe_sort_index | diff --git a/pandas/core/indexes/api.py b/pandas/core/indexes/api.py
index 71ecb358cf575..a9e24bd64922b 100644
--- a/pandas/core/indexes/api.py
+++ b/pandas/core/indexes/api.py
@@ -157,7 +157,7 @@ def _get_combined_index(
index = union_indexes(indexes, sort=False)
index = ensure_index(index)
- if... | - [x] xref #47508 (Replace xxxx with the Github issue number)
as discussed there
| https://api.github.com/repos/pandas-dev/pandas/pulls/47573 | 2022-07-01T18:09:03Z | 2022-07-01T22:16:44Z | 2022-07-01T22:16:44Z | 2022-07-01T22:17:13Z |
Use license_files instead of license_file | diff --git a/setup.cfg b/setup.cfg
index 05b7975cbc0a8..ded05cbb4e413 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -7,7 +7,7 @@ url = https://pandas.pydata.org
author = The Pandas Development Team
author_email = pandas-dev@python.org
license = BSD-3-Clause
-license_file = LICENSE
+license_files = LICENSE
platforms = a... | The license_file parameter is deprecated, use license_files instead
We get this deprecation warning when rebuilding the extensions
| https://api.github.com/repos/pandas-dev/pandas/pulls/47572 | 2022-07-01T18:01:54Z | 2022-07-01T22:12:23Z | 2022-07-01T22:12:23Z | 2022-07-01T22:17:22Z |
BUG: Fixed `tm.set_locale` context manager, it could error and leak when category LC_ALL was used | diff --git a/pandas/_config/localization.py b/pandas/_config/localization.py
index fa5503029fd4b..c4355e954c67c 100644
--- a/pandas/_config/localization.py
+++ b/pandas/_config/localization.py
@@ -39,7 +39,8 @@ def set_locale(
particular locale, without globally setting the locale. This probably isn't
thread-... |
- [x] closes #46595
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [... | https://api.github.com/repos/pandas-dev/pandas/pulls/47570 | 2022-07-01T14:47:13Z | 2022-07-08T22:56:58Z | 2022-07-08T22:56:58Z | 2022-07-11T07:16:06Z |
[DOC] improving the ExcelWriter docstring | diff --git a/pandas/io/excel/_base.py b/pandas/io/excel/_base.py
index 58bb4b1a8f849..0c4268626099a 100644
--- a/pandas/io/excel/_base.py
+++ b/pandas/io/excel/_base.py
@@ -871,11 +871,14 @@ class ExcelWriter(metaclass=abc.ABCMeta):
"""
Class for writing DataFrame objects into excel sheets.
- Default is ... | - [x] closes #47526
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
| https://api.github.com/repos/pandas-dev/pandas/pulls/47568 | 2022-07-01T12:26:35Z | 2022-07-01T17:52:44Z | 2022-07-01T17:52:43Z | 2022-10-20T08:44:36Z |
"Backport PR #47508 on branch 1.4.x REGR: concat materializing index even if sort is not necessary )" | diff --git a/doc/source/whatsnew/v1.4.4.rst b/doc/source/whatsnew/v1.4.4.rst
index b462f0c6a8ffe..0f3d7a55fd6d7 100644
--- a/doc/source/whatsnew/v1.4.4.rst
+++ b/doc/source/whatsnew/v1.4.4.rst
@@ -14,7 +14,7 @@ including other versions of pandas.
Fixed regressions
~~~~~~~~~~~~~~~~~
--
+- Fixed regression in :func:`... | Backport PR #47508 | https://api.github.com/repos/pandas-dev/pandas/pulls/47565 | 2022-07-01T07:21:56Z | 2022-07-02T16:41:44Z | 2022-07-02T16:41:44Z | 2022-07-02T19:18:41Z |
⬆️ UPGRADE: Autoupdate pre-commit config | diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 13e0ecd33359f..3444bc8de6296 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -18,7 +18,7 @@ repos:
pass_filenames: true
require_serial: false
- repo: https://github.com/python/black
- rev: 22.3.0
+ rev:... | <!-- START pr-commits -->
<!-- END pr-commits -->
## Base PullRequest
default branch (https://github.com/pandas-dev/pandas/tree/main)
## Command results
<details>
<summary>Details: </summary>
<details>
<summary><em>add path</em></summary>
```Shell
/home/runner/work/_actions/technote-space/create-pr-action/v2/node_... | https://api.github.com/repos/pandas-dev/pandas/pulls/47564 | 2022-07-01T07:08:08Z | 2022-07-06T16:59:53Z | 2022-07-06T16:59:53Z | 2022-07-06T16:59:56Z |
TYP: fix a few errors found by pandas-stub | diff --git a/pandas/_testing/asserters.py b/pandas/_testing/asserters.py
index 90ee600c1967d..7c89946a0c12f 100644
--- a/pandas/_testing/asserters.py
+++ b/pandas/_testing/asserters.py
@@ -864,7 +864,7 @@ def assert_series_equal(
check_dtype: bool | Literal["equiv"] = True,
check_index_type="equiv",
chec... | There are (unsurprisingly) many errors when trying to use pyright/mypy to validate pandas-stub's tests against the pandas annotations. This PR fixes three of them. | https://api.github.com/repos/pandas-dev/pandas/pulls/47562 | 2022-07-01T03:30:09Z | 2022-07-03T14:21:18Z | 2022-07-03T14:21:18Z | 2022-09-21T15:28:31Z |
DEPR: numeic_only in Series and SeriesGroupBy consistency | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index d237ee9921356..28abfebce1ffc 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -275,6 +275,7 @@ Other enhancements
- :class:`.DataError`, :class:`.SpecificationError`, :class:`.SettingWithCopyError`, :c... | Part of #47500
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [x] Ad... | https://api.github.com/repos/pandas-dev/pandas/pulls/47561 | 2022-07-01T03:05:31Z | 2022-07-05T16:42:33Z | 2022-07-05T16:42:32Z | 2022-07-06T22:14:07Z |
TYP: fix type of level in DataFrame.groupby | diff --git a/pandas/_typing.py b/pandas/_typing.py
index a1bb119c32ba6..ac1237f8841be 100644
--- a/pandas/_typing.py
+++ b/pandas/_typing.py
@@ -109,7 +109,7 @@
Axis = Union[str, int]
IndexLabel = Union[Hashable, Sequence[Hashable]]
-Level = Union[Hashable, int]
+Level = Hashable
Shape = Tuple[int, ...]
Suffixes ... | fixes #47548 | https://api.github.com/repos/pandas-dev/pandas/pulls/47560 | 2022-07-01T02:12:49Z | 2022-07-01T17:50:11Z | 2022-07-01T17:50:11Z | 2022-09-21T15:28:31Z |
TST: Test aggregate with list values #25581 | diff --git a/pandas/tests/groupby/aggregate/test_aggregate.py b/pandas/tests/groupby/aggregate/test_aggregate.py
index d52b6ceaf8990..54ee32502bbc9 100644
--- a/pandas/tests/groupby/aggregate/test_aggregate.py
+++ b/pandas/tests/groupby/aggregate/test_aggregate.py
@@ -1413,3 +1413,28 @@ def test_multi_axis_1_raises(fun... | - [ ] closes #25581
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ]... | https://api.github.com/repos/pandas-dev/pandas/pulls/47559 | 2022-07-01T01:46:37Z | 2022-07-05T22:22:19Z | 2022-07-05T22:22:19Z | 2022-07-05T22:22:29Z |
TYP: misc return type annotations | diff --git a/pandas/__init__.py b/pandas/__init__.py
index 1c4151372273b..01ff2e1e1f181 100644
--- a/pandas/__init__.py
+++ b/pandas/__init__.py
@@ -1,4 +1,5 @@
# flake8: noqa
+from __future__ import annotations
__docformat__ = "restructuredtext"
@@ -185,7 +186,7 @@
__deprecated_num_index_names = ["Float64Index"... | After this most of the low hanging return annotations that `pyright --createstub pandas` finds are in pandas/core (there are still plenty of more tricky return annotations).
xref #47521 | https://api.github.com/repos/pandas-dev/pandas/pulls/47558 | 2022-07-01T01:41:45Z | 2022-07-03T14:22:54Z | 2022-07-03T14:22:53Z | 2022-09-21T15:28:31Z |
ENH: RangeIndex._shallow_copy can return RangeIndex | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index c70acc0a0b18c..6f7e150965583 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -277,7 +277,7 @@ Other enhancements
- Allow reading compressed SAS files with :func:`read_sas` (e.g., ``.sas7bdat.gz`` file... | - [x] closes #46675 (Replace xxxx with the Github issue number)
- [x] closes #43885
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-d... | https://api.github.com/repos/pandas-dev/pandas/pulls/47557 | 2022-07-01T00:17:47Z | 2022-07-08T23:58:32Z | 2022-07-08T23:58:31Z | 2022-07-09T00:12:05Z |
REF: share some constructor code | diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index d3c4815af5759..00dc8b2a4a13b 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -94,6 +94,10 @@
DatetimeTZDtype,
ExtensionDtype,
)
+from pandas.core.dtypes.generic import (
+ ... | - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/con... | https://api.github.com/repos/pandas-dev/pandas/pulls/47555 | 2022-06-30T21:52:37Z | 2022-07-01T02:04:29Z | 2022-07-01T02:04:29Z | 2022-07-01T14:29:33Z |
REF: Reduce duplicative methods between XML parser classes | diff --git a/pandas/io/xml.py b/pandas/io/xml.py
index 83cc01752682f..95fac0c739895 100644
--- a/pandas/io/xml.py
+++ b/pandas/io/xml.py
@@ -7,6 +7,7 @@
import io
from typing import (
Any,
+ Callable,
Sequence,
)
@@ -177,7 +178,7 @@ def parse_data(self) -> list[dict[str, str | None]]:
raise... | - [X] Relates to #40131
- [X] [Tests passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests).
- [X] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ] Added [type annotations](https://pandas.pyda... | https://api.github.com/repos/pandas-dev/pandas/pulls/47553 | 2022-06-30T03:11:47Z | 2022-07-01T17:23:12Z | 2022-07-01T17:23:12Z | 2022-07-01T18:59:29Z |
ENH/TST: Add BaseMethodsTests tests for ArrowExtensionArray | diff --git a/pandas/core/base.py b/pandas/core/base.py
index 3d18194d14bec..33dbc292660d0 100644
--- a/pandas/core/base.py
+++ b/pandas/core/base.py
@@ -983,10 +983,12 @@ def unique(self):
if not isinstance(values, np.ndarray):
result: ArrayLike = values.unique()
- if self.dtype.kind ... | - [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
| https://api.github.com/repos/pandas-dev/pandas/pulls/47552 | 2022-06-30T00:09:54Z | 2022-07-05T19:59:18Z | 2022-07-05T19:59:18Z | 2022-07-05T19:59:28Z |
ASV: Non-unique DataFrame index | diff --git a/asv_bench/benchmarks/indexing.py b/asv_bench/benchmarks/indexing.py
index 2c0e2e6ca442a..69e3d166943a8 100644
--- a/asv_bench/benchmarks/indexing.py
+++ b/asv_bench/benchmarks/indexing.py
@@ -157,25 +157,39 @@ def time_boolean_rows_boolean(self):
class DataFrameNumericIndexing:
- def setup(self):
+... | - [x] closes #26064
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
I added an asv benchmark for non-unique indices in DataFrames - based on the benchmark of indices in Series. | https://api.github.com/repos/pandas-dev/pandas/pulls/47551 | 2022-06-29T20:49:03Z | 2022-06-30T16:18:32Z | 2022-06-30T16:18:32Z | 2022-06-30T17:01:58Z |
REGR: fix eval with inplace=True to correctly update column values inplace | diff --git a/doc/source/whatsnew/v1.4.4.rst b/doc/source/whatsnew/v1.4.4.rst
index 57b8fdee5888a..1e7ed256c05ef 100644
--- a/doc/source/whatsnew/v1.4.4.rst
+++ b/doc/source/whatsnew/v1.4.4.rst
@@ -19,6 +19,7 @@ Fixed regressions
- Fixed regression in :meth:`DataFrame.loc` not updating the cache correctly after values ... | - [x] closes #47449
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [x]... | https://api.github.com/repos/pandas-dev/pandas/pulls/47550 | 2022-06-29T16:32:14Z | 2022-08-19T10:21:24Z | 2022-08-19T10:21:24Z | 2022-08-19T13:16:50Z |
REGR: NotImplementedError: Prefix not defined when slicing offset with loc | diff --git a/doc/source/whatsnew/v1.4.4.rst b/doc/source/whatsnew/v1.4.4.rst
index 927841d42b543..05ebe424a8ea9 100644
--- a/doc/source/whatsnew/v1.4.4.rst
+++ b/doc/source/whatsnew/v1.4.4.rst
@@ -22,6 +22,7 @@ Fixed regressions
- Fixed regression in :meth:`DataFrame.loc` not updating the cache correctly after values ... | - [x] closes #46671
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [x]... | https://api.github.com/repos/pandas-dev/pandas/pulls/47547 | 2022-06-29T09:09:29Z | 2022-08-23T05:06:32Z | 2022-08-23T05:06:32Z | 2022-08-30T14:10:13Z |
Refactoring code to utilize numpy APIs more | diff --git a/pandas/tests/window/test_numba.py b/pandas/tests/window/test_numba.py
index 89e00af270a02..1284be898112a 100644
--- a/pandas/tests/window/test_numba.py
+++ b/pandas/tests/window/test_numba.py
@@ -56,9 +56,7 @@ class TestEngine:
@pytest.mark.parametrize("jit", [True, False])
def test_numba_vs_cyth... |
Thank you very much for your excellent work in pandas.
I am a graduate student at the University of Colorado, studying the best practices of evolving data science codes. From our research, one of the most common evolution best practice in ML code is the migration of loop-based computations, since it improves perfo... | https://api.github.com/repos/pandas-dev/pandas/pulls/47546 | 2022-06-29T08:40:34Z | 2022-06-29T15:12:36Z | null | 2022-06-29T17:25:27Z |
DOC: Convert URL example to static code block | diff --git a/doc/source/user_guide/io.rst b/doc/source/user_guide/io.rst
index 4c5d189e1bba3..7d1aa76613d33 100644
--- a/doc/source/user_guide/io.rst
+++ b/doc/source/user_guide/io.rst
@@ -2559,16 +2559,29 @@ Let's look at a few examples.
Read a URL with no options:
-.. ipython:: python
+.. code-block:: ipython
... | - [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
Avoids flaky doc build failure if URL is not available: https://github.com/pandas-dev/pandas/runs/7100909800?check_suite_focus=true | https://api.github.com/repos/pandas-dev/pandas/pulls/47540 | 2022-06-28T23:19:38Z | 2022-06-30T20:49:55Z | 2022-06-30T20:49:55Z | 2022-06-30T20:49:58Z |
Update `to_gbq` wrapper method to contain `api_method` parameter | diff --git a/ci/deps/actions-38-minimum_versions.yaml b/ci/deps/actions-38-minimum_versions.yaml
index 3ab27830060b2..7a5d14e9dec84 100644
--- a/ci/deps/actions-38-minimum_versions.yaml
+++ b/ci/deps/actions-38-minimum_versions.yaml
@@ -37,7 +37,7 @@ dependencies:
- numexpr=2.7.3
- odfpy=1.4.1
- openpyxl=3.0.7... | ENH: add api_method parameter and some documentation
DOC: update dependencies to require at least version 0.16.0 of pandas-gbq
- [ ] closes #46117
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
... | https://api.github.com/repos/pandas-dev/pandas/pulls/47539 | 2022-06-28T22:40:43Z | 2022-08-15T16:43:44Z | null | 2022-08-15T16:43:44Z |
BUG: PeriodArray.__sub__(Period) overflows | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 452b4259d4460..40f13726b90b8 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -904,6 +904,7 @@ Period
- Bug in constructing a :class:`Period` from a :class:`Timestamp` or ``np.datetime64`` object with ... | - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/con... | https://api.github.com/repos/pandas-dev/pandas/pulls/47538 | 2022-06-28T21:51:05Z | 2022-06-28T23:22:04Z | 2022-06-28T23:22:04Z | 2022-06-28T23:32:47Z |
ENH: DatetimeIndex.snap support non-nano | diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index 4bc01b8f4ddb0..aacc2a2225743 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -44,7 +44,6 @@
from pandas.util._exceptions import find_stack_level
from pandas.core.dtypes.common import (
- ... | - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/con... | https://api.github.com/repos/pandas-dev/pandas/pulls/47537 | 2022-06-28T21:44:51Z | 2022-06-29T17:12:13Z | 2022-06-29T17:12:13Z | 2022-06-29T17:22:46Z |
ENH/TST: Add BaseParsinngTests tests for ArrowExtensionArray | diff --git a/pandas/core/arrays/arrow/array.py b/pandas/core/arrays/arrow/array.py
index 1c4187f2aafd2..dfb58f0edd127 100644
--- a/pandas/core/arrays/arrow/array.py
+++ b/pandas/core/arrays/arrow/array.py
@@ -63,6 +63,23 @@
ArrowExtensionArrayT = TypeVar("ArrowExtensionArrayT", bound="ArrowExtensionArray")
+def to... | - [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
| https://api.github.com/repos/pandas-dev/pandas/pulls/47536 | 2022-06-28T21:42:48Z | 2022-06-29T16:04:05Z | 2022-06-29T16:04:04Z | 2022-06-29T17:02:39Z |
ENH: DatetimeIndex.indexer_between_time support non-nano | diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index 4bc01b8f4ddb0..50233a9c7cd78 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -26,9 +26,11 @@
)
from pandas._libs.tslibs import (
Resolution,
+ periods_per_day,
timezones,
to... | - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/con... | https://api.github.com/repos/pandas-dev/pandas/pulls/47535 | 2022-06-28T20:45:41Z | 2022-06-28T23:11:33Z | 2022-06-28T23:11:33Z | 2022-06-28T23:32:35Z |
DOC: Add information about StyleFrame, to format Excel output | diff --git a/doc/source/ecosystem.rst b/doc/source/ecosystem.rst
index 256c3ee36e80c..ce00898460710 100644
--- a/doc/source/ecosystem.rst
+++ b/doc/source/ecosystem.rst
@@ -350,6 +350,9 @@ operations on pandas DataFrames. This is useful when migrating from a database t
using pandas or for users more comfortable with S... | Closes #47525
The issue mentions altering the ecosystem page on the pandas website, do you guys know how I would go about doing that?
| https://api.github.com/repos/pandas-dev/pandas/pulls/47533 | 2022-06-28T17:34:35Z | 2022-08-10T04:54:57Z | null | 2022-08-10T04:54:57Z |
WEB: Update to `jupyterlite==0.1.0b10` | diff --git a/environment.yml b/environment.yml
index 0a6055d80c071..eb4d53e116927 100644
--- a/environment.yml
+++ b/environment.yml
@@ -127,4 +127,4 @@ dependencies:
# build the interactive terminal
- jupyterlab >=3.4,<4
- pip:
- - jupyterlite==0.1.0b9
+ - jupyterlite==0.1.0b10
diff --git a/requirem... | Update to the latest `jupyterlite` release for the interactive terminal on the website.
The latest release adds support for caching assets and offline mode, which should help speed things up a little bit, at least when the page is reloaded.
See the release notes for more information: https://github.com/jupyterlit... | https://api.github.com/repos/pandas-dev/pandas/pulls/47532 | 2022-06-28T16:10:38Z | 2022-07-21T16:00:43Z | 2022-07-21T16:00:43Z | 2022-07-22T08:54:56Z |
WEB: Add Telegram to follow us and footer | diff --git a/web/pandas/_templates/layout.html b/web/pandas/_templates/layout.html
index 52e06a9bec55b..67876d88a2d1a 100644
--- a/web/pandas/_templates/layout.html
+++ b/web/pandas/_templates/layout.html
@@ -69,6 +69,11 @@
</main>
<footer class="container pt-4 pt-md-5 border-top">
<ul cl... | Since we've been posting way more in Telegram than in Twitter, probably worth adding it to the website.
Adding buttons here in the web footer, next to the other icons, and in the home page, in the `Follow us` section (I changed the twitter banner to a button, which I think looks better with more than one item).
T... | https://api.github.com/repos/pandas-dev/pandas/pulls/47531 | 2022-06-28T14:45:24Z | 2022-06-28T20:15:48Z | 2022-06-28T20:15:48Z | 2022-06-30T09:51:28Z |
WARN: Clarify datetime warning when can't parse in accordance with dayfirst | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 56b09348189ee..2fed373a5c79b 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -727,6 +727,7 @@ Other Deprecations
- Deprecated the ``display.column_space`` global configuration option (:issue:`7576`)
... | - [x] closes #46210 (Replace xxxx with the Github issue number)
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/co... | https://api.github.com/repos/pandas-dev/pandas/pulls/47528 | 2022-06-28T12:10:29Z | 2022-06-28T21:44:13Z | 2022-06-28T21:44:12Z | 2022-06-28T21:44:19Z |
TYP: more return annotations for io/* | diff --git a/pandas/io/common.py b/pandas/io/common.py
index d692f26ab0576..ef8b466145daa 100644
--- a/pandas/io/common.py
+++ b/pandas/io/common.py
@@ -925,7 +925,7 @@ class _BufferedWriter(BytesIO, ABC): # type: ignore[misc]
"""
@abstractmethod
- def write_to_buffer(self):
+ def write_to_buffer(sel... | null | https://api.github.com/repos/pandas-dev/pandas/pulls/47524 | 2022-06-28T02:29:04Z | 2022-06-28T17:06:59Z | 2022-06-28T17:06:59Z | 2022-06-28T17:07:07Z |
CI: Bump Mac/Windows build timeout to 120 minutes | diff --git a/.github/workflows/macos-windows.yml b/.github/workflows/macos-windows.yml
index 7052b770e2586..cf9a59400bc92 100644
--- a/.github/workflows/macos-windows.yml
+++ b/.github/workflows/macos-windows.yml
@@ -23,7 +23,7 @@ jobs:
defaults:
run:
shell: bash -el {0}
- timeout-minutes: 90
+ ... | Needed since Windows builds are running with 1 worker #47443 | https://api.github.com/repos/pandas-dev/pandas/pulls/47523 | 2022-06-28T00:10:25Z | 2022-07-08T22:18:45Z | 2022-07-08T22:18:45Z | 2022-07-08T22:18:48Z |
ENH: TimedeltaArray add/sub with NaT preserve reso | diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index d354d28d0f46f..5e65b124ae0f4 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -1087,7 +1087,7 @@ def _cmp_method(self, other, op):
__rdivmod__ = make_invalid_op("__rdivmod__")
... | - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/con... | https://api.github.com/repos/pandas-dev/pandas/pulls/47522 | 2022-06-27T23:52:32Z | 2022-06-28T18:38:44Z | 2022-06-28T18:38:44Z | 2022-06-28T20:42:30Z |
added link to advanced indexing guide in .loc docstring | diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index 09fa08339bd43..22b03b3b2e47e 100644
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -521,6 +521,9 @@ def loc(self) -> _LocIndexer:
sidewinder mark i 10 20
mark ii 1 4
vi... | closes #46620
Not sure if the online documentation also needs to change with this docstring.
if it does, how can I change that? | https://api.github.com/repos/pandas-dev/pandas/pulls/47520 | 2022-06-27T18:44:34Z | 2022-06-28T00:08:03Z | 2022-06-28T00:08:02Z | 2022-06-28T00:08:11Z |
PERF: use c-division in nancorr | diff --git a/pandas/_libs/algos.pyx b/pandas/_libs/algos.pyx
index 29f9a22c9b36e..c05d6a300ccf0 100644
--- a/pandas/_libs/algos.pyx
+++ b/pandas/_libs/algos.pyx
@@ -324,6 +324,7 @@ def kth_smallest(numeric_t[::1] arr, Py_ssize_t k) -> numeric_t:
@cython.boundscheck(False)
@cython.wraparound(False)
+@cython.cdivisio... | - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/con... | https://api.github.com/repos/pandas-dev/pandas/pulls/47518 | 2022-06-27T15:11:57Z | 2022-07-03T15:02:13Z | 2022-07-03T15:02:13Z | 2022-07-03T15:02:17Z |
DOC: Fix a typo in documentation for styler | diff --git a/doc/source/user_guide/style.ipynb b/doc/source/user_guide/style.ipynb
index 58187b3052819..43021fcbc13fb 100644
--- a/doc/source/user_guide/style.ipynb
+++ b/doc/source/user_guide/style.ipynb
@@ -151,7 +151,7 @@
"\n",
"### Formatting Values\n",
"\n",
- "Before adding styles it is useful t... | datavlaues => datavalues
| https://api.github.com/repos/pandas-dev/pandas/pulls/47517 | 2022-06-27T07:09:17Z | 2022-06-27T16:28:11Z | 2022-06-27T16:28:11Z | 2022-06-27T16:28:18Z |
TYP: Return annotations for io/{formats,json} | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 932805463d1c3..6c0a747b16745 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -1008,7 +1008,7 @@ def _repr_fits_horizontal_(self, ignore_width: bool = False) -> bool:
# used by repr_html under IPython notebook or scripts ignore ter... | null | https://api.github.com/repos/pandas-dev/pandas/pulls/47516 | 2022-06-27T01:19:53Z | 2022-06-27T22:01:22Z | 2022-06-27T22:01:21Z | 2022-09-21T15:28:31Z |
ENH/TST: Add BaseGroupbyTests tests for ArrowExtensionArray | diff --git a/pandas/core/dtypes/missing.py b/pandas/core/dtypes/missing.py
index 37b42ad66c027..e809e761ebbb2 100644
--- a/pandas/core/dtypes/missing.py
+++ b/pandas/core/dtypes/missing.py
@@ -41,6 +41,7 @@
)
from pandas.core.dtypes.dtypes import (
CategoricalDtype,
+ DatetimeTZDtype,
ExtensionDtype,
... | - [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
| https://api.github.com/repos/pandas-dev/pandas/pulls/47515 | 2022-06-27T00:23:49Z | 2022-07-03T14:24:31Z | 2022-07-03T14:24:31Z | 2022-07-05T16:45:44Z |
"Backport PR #47387 on branch 1.4.x (TST,WARN: read_csv raises warning at wrong stacklevel, but _assert_raised_with_correct_stacklevel doesn't fail )" | diff --git a/doc/source/whatsnew/v1.4.4.rst b/doc/source/whatsnew/v1.4.4.rst
index b462f0c6a8ffe..ef9537200bccd 100644
--- a/doc/source/whatsnew/v1.4.4.rst
+++ b/doc/source/whatsnew/v1.4.4.rst
@@ -23,7 +23,7 @@ Fixed regressions
Bug fixes
~~~~~~~~~
--
+- The :class:`errors.FutureWarning` raised when passing argumen... | Backport PR #47387 | https://api.github.com/repos/pandas-dev/pandas/pulls/47513 | 2022-06-26T19:16:54Z | 2022-07-02T17:04:03Z | 2022-07-02T17:04:03Z | 2022-07-02T17:04:13Z |
TYP: some return annotations in pytables.py | diff --git a/pandas/io/pytables.py b/pandas/io/pytables.py
index c20ce0c847b61..b96fa4a57f188 100644
--- a/pandas/io/pytables.py
+++ b/pandas/io/pytables.py
@@ -19,9 +19,11 @@
Any,
Callable,
Hashable,
+ Iterator,
Literal,
Sequence,
cast,
+ overload,
)
import warnings
@@ -592,7 +5... | Mostly the low-hanging fruit in pytables.py | https://api.github.com/repos/pandas-dev/pandas/pulls/47512 | 2022-06-26T16:39:44Z | 2022-06-26T19:23:30Z | 2022-06-26T19:23:30Z | 2022-09-21T15:28:31Z |
PERF: lexsort_depth | diff --git a/asv_bench/benchmarks/multiindex_object.py b/asv_bench/benchmarks/multiindex_object.py
index a498c6b2e4944..782eb15234ea4 100644
--- a/asv_bench/benchmarks/multiindex_object.py
+++ b/asv_bench/benchmarks/multiindex_object.py
@@ -24,6 +24,13 @@ def setup(self):
self.mi_small = MultiIndex.from_produc... | - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/con... | https://api.github.com/repos/pandas-dev/pandas/pulls/47511 | 2022-06-26T13:50:39Z | 2022-07-10T10:06:23Z | null | 2022-07-10T10:06:24Z |
TYP: Missing return annotations in util/tseries/plotting | diff --git a/pandas/plotting/_misc.py b/pandas/plotting/_misc.py
index 6e7b53e4c5ae4..0e82a0fc924fb 100644
--- a/pandas/plotting/_misc.py
+++ b/pandas/plotting/_misc.py
@@ -1,7 +1,18 @@
+from __future__ import annotations
+
from contextlib import contextmanager
+from typing import (
+ TYPE_CHECKING,
+ Iterator,
... | Found with
```sh
pyright --createstub pandas
grep -R "# -> " typings/pandas/
```
Pyright can infer many of the missing return annotations :) | https://api.github.com/repos/pandas-dev/pandas/pulls/47510 | 2022-06-26T02:16:40Z | 2022-06-27T16:50:04Z | 2022-06-27T16:50:04Z | 2022-09-21T15:29:48Z |
TYP: misc | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 6c0a747b16745..a8c33a144378e 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -5545,7 +5545,7 @@ def replace(
inplace: bool = False,
limit=None,
regex: bool = False,
- method: str | lib.NoDefault = lib.no_def... | null | https://api.github.com/repos/pandas-dev/pandas/pulls/47509 | 2022-06-25T22:50:22Z | 2022-06-28T17:11:20Z | 2022-06-28T17:11:20Z | 2022-09-21T15:28:31Z |
REGR: concat materializing index even if sort is not necessary | diff --git a/doc/source/whatsnew/v1.4.4.rst b/doc/source/whatsnew/v1.4.4.rst
index b462f0c6a8ffe..0f3d7a55fd6d7 100644
--- a/doc/source/whatsnew/v1.4.4.rst
+++ b/doc/source/whatsnew/v1.4.4.rst
@@ -14,7 +14,7 @@ including other versions of pandas.
Fixed regressions
~~~~~~~~~~~~~~~~~
--
+- Fixed regression in :func:`... | - [x] closes #47501 (Replace xxxx with the Github issue number)
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/co... | https://api.github.com/repos/pandas-dev/pandas/pulls/47508 | 2022-06-25T21:20:02Z | 2022-06-30T20:28:18Z | 2022-06-30T20:28:18Z | 2022-07-02T16:38:20Z |
DEPR: pandas.core.groupby | diff --git a/doc/redirects.csv b/doc/redirects.csv
index 173e670e30f0e..4450c00c8e742 100644
--- a/doc/redirects.csv
+++ b/doc/redirects.csv
@@ -165,78 +165,78 @@ generated/pandas.CategoricalIndex.reorder_categories,../reference/api/pandas.Cat
generated/pandas.CategoricalIndex.set_categories,../reference/api/pandas.Ca... | Part of #44993
- [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/d... | https://api.github.com/repos/pandas-dev/pandas/pulls/47507 | 2022-06-25T20:23:42Z | 2022-06-29T21:05:15Z | null | 2022-07-26T20:44:23Z |
TYP: _item_cache and _ixs | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index b4a278185b01b..932805463d1c3 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -3558,16 +3558,16 @@ def T(self) -> DataFrame:
# ----------------------------------------------------------------------
# Indexing Methods
- def _ixs... | - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/con... | https://api.github.com/repos/pandas-dev/pandas/pulls/47506 | 2022-06-25T17:41:06Z | 2022-06-27T16:47:45Z | 2022-06-27T16:47:45Z | 2022-06-27T16:47:51Z |
DEPR/WIP: Deprecate pandas.core | diff --git a/asv_bench/benchmarks/arithmetic.py b/asv_bench/benchmarks/arithmetic.py
index 496db66c78569..4b62a7bc3d4c8 100644
--- a/asv_bench/benchmarks/arithmetic.py
+++ b/asv_bench/benchmarks/arithmetic.py
@@ -11,13 +11,13 @@
date_range,
to_timedelta,
)
+from pandas._core.algorithms import checked_add_wit... | - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/con... | https://api.github.com/repos/pandas-dev/pandas/pulls/47505 | 2022-06-25T16:03:59Z | 2022-06-25T16:44:36Z | null | 2022-07-26T20:44:18Z |
BUG: read_xml iterparse doesn't handle multiple toplevel elements with lxml parser | diff --git a/pandas/io/xml.py b/pandas/io/xml.py
index 78fbeaad09300..9398e995c81ce 100644
--- a/pandas/io/xml.py
+++ b/pandas/io/xml.py
@@ -693,7 +693,7 @@ def _iterparse_nodes(self) -> list[dict[str, str | None]]:
row = None
elem.clear()
- while elem.getprevious(... | - [X] closes #47422
- [X] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [X] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit).
- [ ]... | https://api.github.com/repos/pandas-dev/pandas/pulls/47504 | 2022-06-25T03:54:20Z | 2022-06-27T22:26:49Z | 2022-06-27T22:26:49Z | 2022-06-28T22:45:56Z |
DOC: Resolve links in whatsnew | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 7e943bb5832e6..a931838fa4910 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -232,7 +232,7 @@ Other enhancements
^^^^^^^^^^^^^^^^^^
- :meth:`Series.map` now raises when ``arg`` is dict but ``na_actio... | - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/con... | https://api.github.com/repos/pandas-dev/pandas/pulls/47499 | 2022-06-24T19:24:15Z | 2022-06-24T20:57:26Z | 2022-06-24T20:57:26Z | 2022-06-24T21:31:27Z |
DOC: Minor fixes in whatsnew 1.5.0 | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 35594fbc8fb8a..b8d8f318611fc 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -477,6 +477,9 @@ Deprecations
.. _whatsnew_150.deprecations.int_slicing_series:
+Label-based integer slicing on a Serie... | - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/con... | https://api.github.com/repos/pandas-dev/pandas/pulls/47498 | 2022-06-24T18:21:11Z | 2022-06-24T20:55:52Z | 2022-06-24T20:55:52Z | 2022-06-24T21:30:42Z |
(WIP) TYP: add some obvious -> None to pandas/core | diff --git a/pandas/core/array_algos/replace.py b/pandas/core/array_algos/replace.py
index 19a44dbfe6f6d..1192191512e10 100644
--- a/pandas/core/array_algos/replace.py
+++ b/pandas/core/array_algos/replace.py
@@ -67,7 +67,7 @@ def compare_or_regex_search(
def _check_comparison_types(
result: ArrayLike |... | - [ ] closes #xxxx (Replace xxxx with the Github issue number)
- [ ] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [ ] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/con... | https://api.github.com/repos/pandas-dev/pandas/pulls/47497 | 2022-06-24T17:59:18Z | 2022-07-28T07:28:19Z | null | 2022-08-20T16:45:19Z |
BUG: read_excel not forward filling index columns when no names are given | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 6fc1ec9c6ff90..a86436fac3487 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -934,6 +934,7 @@ I/O
- Bug in :func:`read_parquet` when ``engine="fastparquet"`` where the file was not closed on error (:i... | - [x] closes #47487 (Replace xxxx with the Github issue number)
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/co... | https://api.github.com/repos/pandas-dev/pandas/pulls/47496 | 2022-06-24T13:05:35Z | 2022-07-03T15:27:34Z | 2022-07-03T15:27:34Z | 2022-07-03T17:10:01Z |
BUG: read_csv ignoring non existing header rows for python engine | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 35594fbc8fb8a..5629ebf604697 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -873,6 +873,7 @@ I/O
- Bug in :func:`read_csv` interpreting second row as :class:`Index` names even when ``index_col=False`... | - [x] closes #47400 (Replace xxxx with the Github issue number)
- [x] [Tests added and passed](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#writing-tests) if fixing a bug or adding a new feature
- [x] All [code checks passed](https://pandas.pydata.org/pandas-docs/dev/development/co... | https://api.github.com/repos/pandas-dev/pandas/pulls/47493 | 2022-06-24T10:21:23Z | 2022-06-24T21:10:11Z | 2022-06-24T21:10:11Z | 2022-06-25T14:23:34Z |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.