maxframe 0.1.0b4__cp37-cp37m-win_amd64.whl → 1.0.0__cp37-cp37m-win_amd64.whl

maxframe/dataframe/misc/tests/test_misc.py

@@ -18,9 +18,11 @@ import pytest
 
 from .... import opcodes
 from ....core import OutputType
+from ....dataframe import DataFrame
 from ....tensor.core import TENSOR_TYPE
 from ... import eval as maxframe_eval
 from ... import get_dummies, to_numeric
+from ...arithmetic import DataFrameGreater, DataFrameLess
 from ...core import CATEGORICAL_TYPE, DATAFRAME_TYPE, INDEX_TYPE, SERIES_TYPE
 from ...datasource.dataframe import from_pandas as from_pandas_df
 from ...datasource.index import from_pandas as from_pandas_index
@@ -347,7 +349,9 @@ def test_drop():
 def test_drop_duplicates():
     rs = np.random.RandomState(0)
     raw = pd.DataFrame(
-        rs.randint(1000, size=(20, 7)), columns=["c" + str(i + 1) for i in range(7)]
+        rs.randint(1000, size=(20, 7)),
+        columns=["c" + str(i + 1) for i in range(7)],
+        index=pd.Index(range(20), name="idx"),
     )
     raw["c7"] = [f"s{j}" for j in range(20)]
 
@@ -359,6 +363,12 @@ def test_drop_duplicates():
     with pytest.raises(KeyError):
         df.drop_duplicates(subset="c8")
 
+    # check index
+    distinct_df = df.drop_duplicates()
+    assert distinct_df.index_value.name == df.index_value.name
+    assert isinstance(df.index_value.to_pandas(), pd.RangeIndex)
+    assert not isinstance(distinct_df.index_value.to_pandas(), pd.RangeIndex)
+
     s = df["c7"]
     with pytest.raises(ValueError):
         s.drop_duplicates(method="unknown")
@@ -405,3 +415,85 @@ def test_to_numeric():
 
     with pytest.raises(ValueError):
         _ = to_numeric([])
+
+
+def test_case_when():
+    rs = np.random.RandomState(0)
+    raw = pd.DataFrame(
+        rs.randint(1000, size=(20, 8)), columns=["c" + str(i + 1) for i in range(8)]
+    )
+    df = from_pandas_df(raw, chunk_size=8)
+
+    with pytest.raises(TypeError):
+        df.c1.case_when(df.c2)
+    with pytest.raises(ValueError):
+        df.c1.case_when([])
+    with pytest.raises(TypeError):
+        df.c1.case_when([[]])
+    with pytest.raises(ValueError):
+        df.c1.case_when([()])
+
+    col = df.c1.case_when([(df.c2 < 10, 10), (df.c2 > 20, df.c3)])
+    assert len(col.inputs) == 4
+    assert isinstance(col.inputs[1].op, DataFrameLess)
+    assert isinstance(col.inputs[2].op, DataFrameGreater)
+
+
+def test_apply():
+    df = DataFrame({"a": [1, 2, 3], "b": [1, 2, 3], "c": [1, 2, 3]})
+
+    keys = [1, 2]
+
+    def f(x, keys):
+        if x["a"] in keys:
+            return [1, 0]
+        else:
+            return [0, 1]
+
+    apply_df = df[["a"]].apply(
+        f,
+        output_type="dataframe",
+        dtypes=pd.Series(["int64", "int64"]),
+        axis=1,
+        result_type="expand",
+        keys=keys,
+    )
+    assert apply_df.shape == (3, 2)
+
+
+def test_pivot_table():
+    from ...groupby.aggregation import DataFrameGroupByAgg
+    from ...misc.pivot_table import DataFramePivotTable
+
+    raw = pd.DataFrame(
+        {
+            "A": "foo foo foo foo foo bar bar bar bar".split(),
+            "B": "one one one two two one one two two".split(),
+            "C": "small large large small small large small small large".split(),
+            "D": [1, 2, 2, 3, 3, 4, 5, 6, 7],
+            "E": [2, 4, 5, 5, 6, 6, 8, 9, 9],
+        }
+    )
+    df = from_pandas_df(raw, chunk_size=8)
+    with pytest.raises(ValueError):
+        df.pivot_table(index=123)
+    with pytest.raises(ValueError):
+        df.pivot_table(index=["F"])
+    with pytest.raises(ValueError):
+        df.pivot_table(values=["D", "E"], aggfunc="sum")
+
+    t = df.pivot_table(index=["A", "B", "C"])
+    assert isinstance(t.op, DataFrameGroupByAgg)
+    t = df.pivot_table(index="A", values=["D", "E"], aggfunc="sum")
+    assert isinstance(t.op, DataFrameGroupByAgg)
+
+    t = df.pivot_table(index=["A", "B"], values=["D", "E"], aggfunc="sum", margins=True)
+    assert isinstance(t.op, DataFramePivotTable)
+
+    t = df.pivot_table(index="A", columns=["B", "C"], aggfunc="sum")
+    assert isinstance(t.op, DataFramePivotTable)
+    assert t.shape == (np.nan, np.nan)
+
+    t = df.pivot_table(index=["A", "B"], columns="C", aggfunc="sum")
+    assert isinstance(t.op, DataFramePivotTable)
+    assert t.shape == (np.nan, np.nan)

maxframe/dataframe/misc/transform.py

@@ -228,21 +228,6 @@ def df_transform(df, func, axis=0, *args, dtypes=None, skip_infer=False, **kwarg
     0  1  2
     1  2  3
     2  3  4
-
-    Even though the resulting DataFrame must have the same length as the
-    input DataFrame, it is possible to provide several input functions:
-
-    >>> s = md.Series(range(3))
-    >>> s.execute()
-    0    0
-    1    1
-    2    2
-    dtype: int64
-    >>> s.transform([mt.sqrt, mt.exp]).execute()
-           sqrt        exp
-    0  0.000000   1.000000
-    1  1.000000   2.718282
-    2  1.414214   7.389056
     """
     op = TransformOperator(
         func=func,
@@ -265,6 +250,7 @@ def series_transform(
     dtype=None,
     **kwargs
 ):
+    # FIXME: https://github.com/aliyun/alibabacloud-odps-maxframe-client/issues/10
     """
     Call ``func`` on self producing a Series with transformed values.
 
@@ -332,21 +318,6 @@ def series_transform(
     0  1  2
     1  2  3
     2  3  4
-
-    Even though the resulting Series must have the same length as the
-    input Series, it is possible to provide several input functions:
-
-    >>> s = md.Series(range(3))
-    >>> s.execute()
-    0    0
-    1    1
-    2    2
-    dtype: int64
-    >>> s.transform([mt.sqrt, mt.exp]).execute()
-       sqrt        exp
-    0  0.000000   1.000000
-    1  1.000000   2.718282
-    2  1.414214   7.389056
     """
     op = TransformOperator(
         func=func,

maxframe/dataframe/misc/value_counts.py

@@ -85,6 +85,7 @@ def value_counts(
     dropna=True,
     method="auto",
 ):
+    # FIXME: https://github.com/aliyun/alibabacloud-odps-maxframe-client/issues/33
     """
     Return a Series containing counts of unique values.
 
@@ -125,9 +126,8 @@ def value_counts(
     Examples
     --------
     >>> import maxframe.dataframe as md
-    >>> import maxframe.tensor as mt
-
-    >>> s = md.Series([3, 1, 2, 3, 4, mt.nan])
+    >>> import numpy as np
+    >>> s = md.Series([3, 1, 2, 3, 4, np.nan])
     >>> s.value_counts().execute()
     3.0    2
     4.0    1
@@ -138,7 +138,7 @@ def value_counts(
     With `normalize` set to `True`, returns the relative frequency by
     dividing all values by the sum of values.
 
-    >>> s = md.Series([3, 1, 2, 3, 4, mt.nan])
+    >>> s = md.Series([3, 1, 2, 3, 4, np.nan])
     >>> s.value_counts(normalize=True).execute()
     3.0    0.4
     4.0    0.2
@@ -146,19 +146,6 @@ def value_counts(
     1.0    0.2
     dtype: float64
 
-    **bins**
-
-    Bins can be useful for going from a continuous variable to a
-    categorical variable; instead of counting unique
-    apparitions of values, divide the index in the specified
-    number of half-open bins.
-
-    >>> s.value_counts(bins=3).execute()
-    (2.0, 3.0]      2
-    (0.996, 2.0]    2
-    (3.0, 4.0]      1
-    dtype: int64
-
     **dropna**
 
     With `dropna` set to `False` we can also see NaN index values.

maxframe/dataframe/missing/dropna.py

@@ -234,7 +234,7 @@ def series_dropna(series, axis=0, inplace=False, how=None):
     Empty strings are not considered NA values. ``None`` is considered an
     NA value.
 
-    >>> ser = md.Series([np.NaN, 2, md.NaT, '', None, 'I stay'])
+    >>> ser = md.Series([np.NaN, '2', md.NaT, '', None, 'I stay'])
     >>> ser.execute()
     0       NaN
     1         2

maxframe/dataframe/missing/fillna.py

@@ -132,11 +132,11 @@ def fillna(
     --------
     >>> import maxframe.tensor as mt
     >>> import maxframe.dataframe as md
-    >>> df = md.DataFrame([[mt.nan, 2, mt.nan, 0],
-    ...                    [3, 4, mt.nan, 1],
-    ...                    [mt.nan, mt.nan, mt.nan, 5],
-    ...                    [mt.nan, 3, mt.nan, 4]],
-    ...                   columns=list('ABCD'))
+    >>> df = md.DataFrame([[np.nan, 2, np.nan, 0],
+                           [3, 4, np.nan, 1],
+                           [np.nan, np.nan, np.nan, 5],
+                           [np.nan, 3, np.nan, 4]],
+                          columns=list('ABCD'))
     >>> df.execute()
          A    B   C  D
     0  NaN  2.0 NaN  0

maxframe/dataframe/operators.py

@@ -16,13 +16,7 @@ import numpy as np
 import pandas as pd
 
 from ..core import ENTITY_TYPE, OutputType
-from ..core.operator import (
-    Fuse,
-    FuseChunkMixin,
-    Operator,
-    ShuffleProxy,
-    TileableOperatorMixin,
-)
+from ..core.operator import Operator, ShuffleProxy, TileableOperatorMixin
 from ..tensor.core import TENSOR_TYPE
 from ..tensor.datasource import tensor as astensor
 from .core import DATAFRAME_TYPE, SERIES_TYPE
@@ -261,13 +255,3 @@ DataFrameOperator = Operator
 class DataFrameShuffleProxy(ShuffleProxy, DataFrameOperatorMixin):
     def __init__(self, sparse=None, output_types=None, **kwargs):
         super().__init__(sparse=sparse, _output_types=output_types, **kwargs)
-
-
-class DataFrameFuseChunkMixin(FuseChunkMixin, DataFrameOperatorMixin):
-    __slots__ = ()
-
-
-class DataFrameFuseChunk(Fuse, DataFrameFuseChunkMixin):
-    @property
-    def output_types(self):
-        return self.outputs[-1].chunk.op.output_types

maxframe/dataframe/plotting/core.py

@@ -17,7 +17,7 @@ from collections import OrderedDict
 import pandas as pd
 
 from ...core import ENTITY_TYPE, ExecutableTuple
-from ...utils import adapt_docstring
+from ...utils import adapt_docstring, get_item_if_scalar
 
 
 class PlotAccessor:
@@ -34,7 +34,7 @@ class PlotAccessor:
             .fetch(session=session)
         )
         for p, v in zip(to_executes, executed):
-            result[p] = v
+            result[p] = get_item_if_scalar(v)
 
         data = result.pop("__object__")
         pd_kwargs = kwargs.copy()

maxframe/dataframe/reduction/core.py

@@ -30,7 +30,7 @@ from ...serialization.serializables import (
     StringField,
 )
 from ...typing_ import TileableType
-from ...utils import pd_release_version, tokenize
+from ...utils import get_item_if_scalar, pd_release_version, tokenize
 from ..operators import DATAFRAME_TYPE, DataFrameOperator, DataFrameOperatorMixin
 from ..utils import (
     build_df,
@@ -552,7 +552,7 @@ class ReductionCompiler:
     @enter_mode(build=True)
     def _compile_function(self, func, func_name=None, ndim=1) -> ReductionSteps:
         from ...tensor.arithmetic.core import TensorBinOp, TensorUnaryOp
-        from ...tensor.base import TensorWhere
+        from ...tensor.misc import TensorWhere
         from ..arithmetic.core import DataFrameBinOp, DataFrameUnaryOp
         from ..datasource.dataframe import DataFrameDataSource
         from ..datasource.series import SeriesDataSource
@@ -679,8 +679,8 @@ class ReductionCompiler:
         ]
         """
         from ...tensor.arithmetic.core import TensorBinOp, TensorUnaryOp
-        from ...tensor.base import TensorWhere
         from ...tensor.datasource import Scalar
+        from ...tensor.misc import TensorWhere
         from ..arithmetic.core import DataFrameBinOp, DataFrameUnaryOp
         from ..datasource.dataframe import DataFrameDataSource
         from ..datasource.series import SeriesDataSource
@@ -715,6 +715,7 @@ class ReductionCompiler:
                 keys_to_vars = {inp.key: local_key_to_var[inp.key] for inp in t.inputs}
 
                 def _interpret_var(v):
+                    v = get_item_if_scalar(v)
                     # get representation for variables
                     if hasattr(v, "key"):
                         return keys_to_vars[v.key]

maxframe/dataframe/reduction/tests/test_reduction.py

@@ -23,6 +23,7 @@ import pytest
 
 from .... import dataframe as md
 from ....tensor import Tensor
+from ....tests.utils import assert_mf_index_dtype
 from ...core import DataFrame, IndexValue, OutputType, Series
 from ...datasource.dataframe import from_pandas as from_pandas_df
 from ...datasource.series import from_pandas as from_pandas_series
@@ -111,10 +112,7 @@ def test_dataframe_reduction(func_name, op, func_opts: FunctionOptions):
     reduction_df = getattr(from_pandas_df(data, chunk_size=3), func_name)()
 
     assert isinstance(reduction_df, Series)
-    assert isinstance(
-        reduction_df.index_value._index_value,
-        (IndexValue.RangeIndex, IndexValue.Int64Index),
-    )
+    assert_mf_index_dtype(reduction_df.index_value._index_value, np.int64)
     assert reduction_df.shape == (10,)
 
     data = pd.DataFrame(np.random.rand(20, 20), index=[str(i) for i in range(20)])

maxframe/dataframe/sort/sort_values.py

@@ -67,6 +67,7 @@ def dataframe_sort_values(
     parallel_kind="PSRS",
     psrs_kinds=None,
 ):
+    # FIXME: https://github.com/aliyun/alibabacloud-odps-maxframe-client/issues/15
     """
     Sort by the values along either axis.
 
@@ -152,17 +153,6 @@ def dataframe_sort_values(
     0   A    2    0
     1   A    1    1
     3   NaN  8    4
-
-    Putting NAs first
-
-    >>> df.sort_values(by='col1', ascending=False, na_position='first').execute()
-        col1 col2 col3
-    3   NaN  8    4
-    4   D    7    2
-    5   C    4    3
-    2   B    9    9
-    0   A    2    0
-    1   A    1    1
     """
 
     if na_position not in ["last", "first"]:  # pragma: no cover

maxframe/dataframe/statistics/corr.py

@@ -43,7 +43,7 @@ class DataFrameCorr(DataFrameOperator, DataFrameOperatorMixin):
     def __call__(self, df_or_series):
         if isinstance(df_or_series, SERIES_TYPE):
             inputs = filter_inputs([df_or_series, self.other])
-            return self.new_scalar(inputs, dtype=np.dtype(np.float_))
+            return self.new_scalar(inputs, dtype=np.dtype(float))
         else:
 
             def _filter_numeric(obj):
@@ -60,7 +60,7 @@ class DataFrameCorr(DataFrameOperator, DataFrameOperatorMixin):
             inputs = filter_inputs([df_or_series, self.other])
             if self.axis is None:
                 dtypes = pd.Series(
-                    [np.dtype(np.float_)] * len(df_or_series.dtypes),
+                    [np.dtype(float)] * len(df_or_series.dtypes),
                     index=df_or_series.dtypes.index,
                 )
                 return self.new_dataframe(
@@ -85,7 +85,7 @@ class DataFrameCorr(DataFrameOperator, DataFrameOperatorMixin):
                 return self.new_series(
                     inputs,
                     shape=shape,
-                    dtype=np.dtype(np.float_),
+                    dtype=np.dtype(float),
                     index_value=new_index_value,
                 )
 

maxframe/dataframe/statistics/quantile.py

@@ -14,8 +14,9 @@
 
 import numpy as np
 import pandas as pd
+from pandas.core.dtypes.cast import find_common_type
 
-from ... import opcodes as OperandDef
+from ... import opcodes
 from ...core import ENTITY_TYPE
 from ...serialization.serializables import (
     AnyField,
@@ -32,11 +33,11 @@ from ...tensor.datasource import tensor as astensor
 from ...tensor.statistics.quantile import quantile as tensor_quantile
 from ..core import DATAFRAME_TYPE
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
-from ..utils import build_empty_df, find_common_type, parse_index, validate_axis
+from ..utils import build_empty_df, parse_index, validate_axis
 
 
 class DataFrameQuantile(DataFrameOperator, DataFrameOperatorMixin):
-    _op_type_ = OperandDef.QUANTILE
+    _op_type_ = opcodes.QUANTILE
 
     input = KeyField("input", default=None)
     q = AnyField("q", default=None)
@@ -80,7 +81,10 @@ class DataFrameQuantile(DataFrameOperator, DataFrameOperatorMixin):
             store_index_value = False
         else:
             q_val = np.asanyarray(self.q)
-            pd_index = pd.Index(q_val)
+            if q_val.ndim == 0:
+                pd_index = pd.Index(q_val.reshape(1))
+            else:
+                pd_index = pd.Index(q_val)
             name = self.q if q_val.size == 1 else None
             store_index_value = True
         tokenize_objects = (a, q_val, self.interpolation, type(self).__name__)
@@ -163,7 +167,10 @@ class DataFrameQuantile(DataFrameOperator, DataFrameOperatorMixin):
             store_index_value = False
         else:
             q_val = np.asanyarray(self.q)
-            index_val = pd.Index(q_val)
+            if q_val.ndim == 0:
+                index_val = pd.Index(q_val.reshape(1))
+            else:
+                index_val = pd.Index(q_val)
             store_index_value = True
 
         # get dtype by tensor
@@ -259,6 +266,7 @@ def quantile_series(series, q=0.5, interpolation="linear"):
 
 
 def quantile_dataframe(df, q=0.5, axis=0, numeric_only=True, interpolation="linear"):
+    # FIXME: Timedelta not support. Data invalid: ODPS-0010000:InvalidArgument:duration[ns] is not equal to string
     """
     Return values at the given quantile over requested axis.
 
@@ -309,20 +317,6 @@ def quantile_dataframe(df, q=0.5, axis=0, numeric_only=True, interpolation="line
            a     b
     0.1  1.3   3.7
     0.5  2.5  55.0
-
-    Specifying `numeric_only=False` will also compute the quantile of
-    datetime and timedelta data.
-
-    >>> df = md.DataFrame({'A': [1, 2],
-    ...                    'B': [md.Timestamp('2010'),
-    ...                          md.Timestamp('2011')],
-    ...                    'C': [md.Timedelta('1 days'),
-    ...                          md.Timedelta('2 days')]})
-    >>> df.quantile(0.5, numeric_only=False).execute()
-    A                    1.5
-    B    2010-07-02 12:00:00
-    C        1 days 12:00:00
-    Name: 0.5, dtype: object
     """
     if isinstance(q, ENTITY_TYPE):
         q = astensor(q)

maxframe/dataframe/statistics/tests/test_statistics.py

@@ -49,7 +49,7 @@ def test_dataframe_quantile():
 
     # q = 0.3, axis = 0
     r = s.quantile(0.3)
-    e = raw.quantile(0.3)
+    e = raw.quantile(0.3, numeric_only=True)
     assert isinstance(r, Series)
     assert r.shape == (2,)
     assert r.dtype == e.dtype
@@ -57,7 +57,7 @@ def test_dataframe_quantile():
 
     # q = 0.3, axis = 1
     r = s.quantile(0.3, axis=1)
-    e = raw.quantile(0.3, axis=1)
+    e = raw.quantile(0.3, numeric_only=True, axis=1)
     assert isinstance(r, Series)
     assert r.shape == e.shape
     assert r.dtype == e.dtype
@@ -65,7 +65,7 @@ def test_dataframe_quantile():
 
     # q = [0.3, 0.7], axis = 0
     r = s.quantile([0.3, 0.7])
-    e = raw.quantile([0.3, 0.7])
+    e = raw.quantile([0.3, 0.7], numeric_only=True)
     assert isinstance(r, DataFrame)
     assert r.shape == e.shape
     pd.testing.assert_series_equal(r.dtypes, e.dtypes)
@@ -74,7 +74,7 @@ def test_dataframe_quantile():
 
     # q = [0.3, 0.7], axis = 1
     r = s.quantile([0.3, 0.7], axis=1)
-    e = raw.quantile([0.3, 0.7], axis=1)
+    e = raw.quantile([0.3, 0.7], numeric_only=True, axis=1)
     assert isinstance(r, DataFrame)
     assert r.shape == e.shape
     pd.testing.assert_series_equal(r.dtypes, e.dtypes)

maxframe/dataframe/tests/test_initializer.py

@@ -13,12 +13,13 @@
 # limitations under the License.
 
 import pandas as pd
+import pytest
 
 from ..core import DATAFRAME_TYPE, INDEX_TYPE, SERIES_TYPE
-from ..initializer import read_pandas
+from ..initializer import DataFrame, Series, read_pandas
 
 
-def test_from_pandas():
+def test_read_pandas():
     df_data = pd.DataFrame([["a", 1], ["b", 2]], columns=["a", "b"])
     assert isinstance(read_pandas(df_data), DATAFRAME_TYPE)
 
@@ -27,3 +28,33 @@ def test_from_pandas():
 
     idx_data = pd.Index(["a", "b"])
     assert isinstance(read_pandas(idx_data), INDEX_TYPE)
+
+
+def test_init_dataframe_from_maxframe_series():
+    s = Series([1, 2, 3, 4], index=[1, 2, 3, 4])
+
+    df = DataFrame(s, index=s.index, columns=["col1"])
+
+    assert isinstance(df, DATAFRAME_TYPE)
+    assert df.dtypes.index == ["col1"]
+
+    with pytest.raises(ValueError):
+        DataFrame(s, index=s.index, columns=[])
+
+    with pytest.raises(ValueError):
+        DataFrame(s, index=s.index, columns="col1")
+
+    with pytest.raises(ValueError):
+        DataFrame(s, index=s.index, columns="col2")
+
+
+def test_init_dataframe_from_maxframe_dataframe():
+    df1 = DataFrame({"A": [1, 2, 3, 4], "B": [1, 2, 3, 4]}, index=[1, 2, 3, 4])
+
+    df2 = DataFrame(df1, index=df1.index, columns=["col1", "col2"])
+
+    assert isinstance(df2, DATAFRAME_TYPE)
+    assert list(df2.dtypes.index) == ["col1", "col2"]
+
+    with pytest.raises(ValueError):
+        DataFrame(df1, index=df1.index, columns=["col1", "col2", "col3"])

maxframe/dataframe/utils.py

@@ -26,7 +26,6 @@ import numpy as np
 import pandas as pd
 from pandas.api.extensions import ExtensionDtype
 from pandas.api.types import is_string_dtype
-from pandas.core.dtypes.cast import find_common_type
 from pandas.core.dtypes.inference import is_dict_like, is_list_like
 
 from ..core import Entity, ExecutableTuple
@@ -264,12 +263,30 @@ def parse_index(index_value, *args, store_data=False, key=None):
         return IndexValue(_index_value=_serialize_index(index_value))
 
 
-def gen_unknown_index_value(index_value, *args):
+def gen_unknown_index_value(index_value, *args, normalize_range_index=False):
+    """
+    Generate new index value with the same likes of given index_value and args, but without any value.
+
+    Parameters
+    ----------
+    index_value
+        Given index value.
+    args
+        Arguments for parse_index.
+    normalize_range_index
+        If normalize range index to normal index.
+
+    Returns
+    -------
+        New created range index value.
+    """
     pd_index = index_value.to_pandas()
-    if isinstance(pd_index, pd.RangeIndex):
-        return parse_index(pd.RangeIndex(-1), *args)
+    if not normalize_range_index and isinstance(pd_index, pd.RangeIndex):
+        return parse_index(pd.RangeIndex(-1, name=pd_index.name), *args)
     elif not isinstance(pd_index, pd.MultiIndex):
-        return parse_index(pd.Index([], dtype=pd_index.dtype), *args)
+        return parse_index(
+            pd.Index([], dtype=pd_index.dtype, name=pd_index.name), *args
+        )
     else:
         i = pd.MultiIndex.from_arrays(
             [c[:0] for c in pd_index.levels], names=pd_index.names
@@ -477,11 +494,11 @@ def build_df(df_obj, fill_value=1, size=1, ensure_string=False):
     else:
         fill_values = fill_value
 
-    from .core import SERIES_TYPE
+    from .core import INDEX_TYPE, SERIES_TYPE
 
     dtypes = (
         pd.Series([df_obj.dtype], index=[df_obj.name])
-        if isinstance(df_obj, SERIES_TYPE)
+        if isinstance(df_obj, (INDEX_TYPE, SERIES_TYPE))
         else df_obj.dtypes
     )
     for size, fill_value in zip(sizes, fill_values):
@@ -593,7 +610,7 @@ def build_series(
     return ret_series
 
 
-def infer_index_value(left_index_value, right_index_value):
+def infer_index_value(left_index_value, right_index_value, level=None):
     from .core import IndexValue
 
     if isinstance(left_index_value.value, IndexValue.RangeIndex) and isinstance(
@@ -616,9 +633,7 @@ def infer_index_value(left_index_value, right_index_value):
 
     left_index = left_index_value.to_pandas()
     right_index = right_index_value.to_pandas()
-    out_index = pd.Index(
-        [], dtype=find_common_type([left_index.dtype, right_index.dtype])
-    )
+    out_index = left_index.join(right_index, level=level)[:0]
     return parse_index(out_index, left_index_value, right_index_value)
 
 
@@ -1136,6 +1151,13 @@ def concat_on_columns(objs: List) -> Any:
     return result
 
 
+def apply_if_callable(maybe_callable, obj, **kwargs):
+    if callable(maybe_callable):
+        return maybe_callable(obj, **kwargs)
+
+    return maybe_callable
+
+
 def patch_sa_engine_execute():
     """
     pandas did not resolve compatibility issue of sqlalchemy 2.0, the issue

maxframe/dataframe/window/expanding.py

@@ -28,6 +28,7 @@ from .aggregation import BaseDataFrameExpandingAgg
 from .core import Window
 
 _window_has_method = pd_release_version >= (1, 3, 0)
+_window_has_center = pd_release_version < (2, 0, 0)
 
 
 class DataFrameExpandingAgg(BaseDataFrameExpandingAgg):
@@ -49,10 +50,11 @@ class Expanding(Window):
     def params(self):
         p = OrderedDict()
 
+        args = ["min_periods", "center", "axis", "method"]
         if not _window_has_method:  # pragma: no cover
-            args = ["min_periods", "center", "axis"]
-        else:
-            args = ["min_periods", "center", "axis", "method"]
+            args = [a for a in args if a != "method"]
+        if not _window_has_center:
+            args = [a for a in args if a != "center"]
 
         for k in args:
             p[k] = getattr(self, k)