maxframe 0.1.0b5__cp310-cp310-win32.whl → 1.0.0__cp310-cp310-win32.whl

maxframe/core/entity/tests/test_objects.py

@@ -0,0 +1,43 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ..objects import Object, ObjectData
+
+
+class TestSubObjectData(ObjectData):
+    __test__ = False
+
+
+class TestSubObject(Object):
+    __test__ = False
+
+
+def test_object_init():
+    assert TestSubObjectData.get_entity_class() is TestSubObject
+
+    obj = ObjectData(
+        object_class=TestSubObjectData.__module__ + "#" + TestSubObjectData.__name__
+    )
+    assert isinstance(obj, TestSubObjectData)
+
+    obj = ObjectData(object_class=TestSubObjectData)
+    assert isinstance(obj, TestSubObjectData)
+
+    obj = ObjectData(
+        object_class=TestSubObject.__module__ + "#" + TestSubObject.__name__
+    )
+    assert isinstance(obj, TestSubObjectData)
+
+    obj = ObjectData(object_class=TestSubObject)
+    assert isinstance(obj, TestSubObjectData)

maxframe/core/entity/tileables.py

@@ -15,17 +15,15 @@
 import builtins
 import itertools
 from operator import attrgetter
-from typing import Callable, List
 from weakref import WeakKeyDictionary, WeakSet
 
 import numpy as np
 
 from ...serialization.serializables import BoolField, FieldTypes, TupleField
-from ...typing_ import OperatorType, TileableType
+from ...typing_ import TileableType
 from ...utils import on_deserialize_shape, on_serialize_nsplits, on_serialize_shape
 from ..base import Base
 from ..mode import enter_mode
-from .chunks import Chunk
 from .core import Entity, EntityData
 from .executable import _ExecutableMixin
 
@@ -34,79 +32,6 @@ class NotSupportTile(Exception):
     pass
 
 
-class OperatorTilesHandler:
-    _handlers = dict()
-
-    @classmethod
-    def _get_op_cls(cls, op: OperatorType):
-        if isinstance(op, type):
-            return op
-        return type(op)
-
-    @classmethod
-    def register(
-        cls, op: OperatorType, tile_handler: Callable[[OperatorType], TileableType]
-    ):
-        cls._handlers[cls._get_op_cls(op)] = tile_handler
-
-    @classmethod
-    def unregister(cls, op: OperatorType):
-        del cls._handlers[cls._get_op_cls(op)]
-
-    @classmethod
-    def get_handler(
-        cls, op: OperatorType
-    ) -> Callable[[OperatorType], List[TileableType]]:
-        op_cls = cls._get_op_cls(op)
-        return cls._handlers.get(op_cls, op_cls.tile)
-
-    @classmethod
-    def _assign_to(
-        cls,
-        tile_after_tensor_datas: List["TileableData"],
-        tile_before_tensor_datas: List["TileableData"],
-    ):
-        assert len(tile_after_tensor_datas) == len(tile_before_tensor_datas)
-
-        for tile_after_tensor_data, tile_before_tensor_data in zip(
-            tile_after_tensor_datas, tile_before_tensor_datas
-        ):
-            if tile_before_tensor_data is None:
-                # garbage collected
-                continue
-            tile_after_tensor_data.copy_to(tile_before_tensor_data)
-            tile_before_tensor_data.op.outputs = tile_before_tensor_datas
-
-    @enter_mode(kernel=True)
-    def dispatch(self, op: OperatorType):
-        op_cls = self._get_op_cls(op)
-        tiled = None
-        cause = None
-
-        if op_cls in self._handlers:
-            tiled = self._handlers[op_cls](op)
-        else:
-            try:
-                tiled = op_cls.tile(op)
-            except NotImplementedError as ex:
-                cause = ex
-                for super_cls in op_cls.__mro__:
-                    if super_cls in self._handlers:
-                        h = self._handlers[op_cls] = self._handlers[super_cls]
-                        tiled = h(op)
-                        break
-
-        if tiled is not None:
-            return tiled if isinstance(tiled, list) else [tiled]
-        else:
-            raise NotImplementedError(f"{type(op)} does not support tile") from cause
-
-
-handler = OperatorTilesHandler()
-register = OperatorTilesHandler.register
-unregister = OperatorTilesHandler.unregister
-
-
 class _ChunksIndexer:
     __slots__ = ("_tileable",)
 
@@ -231,7 +156,7 @@ entity_view_handler = EntityDataModificationHandler()
 
 
 class TileableData(EntityData, _ExecutableMixin):
-    __slots__ = "_cix", "_entities", "_executed_sessions"
+    __slots__ = "_chunks", "_cix", "_entities", "_executed_sessions"
     _no_copy_attrs_ = Base._no_copy_attrs_ | {"_cix"}
 
     # optional fields
@@ -245,6 +170,8 @@ class TileableData(EntityData, _ExecutableMixin):
     cache = BoolField("cache", default=False)
 
     def __init__(self: TileableType, *args, **kwargs):
+        if kwargs.get("chunks") is not None:
+            self._chunks = kwargs.pop("chunks")
         if kwargs.get("_nsplits", None) is not None:
             kwargs["_nsplits"] = tuple(tuple(s) for s in kwargs["_nsplits"])
 
@@ -270,7 +197,7 @@ class TileableData(EntityData, _ExecutableMixin):
             return tuple(map(len, self._nsplits))
 
     @property
-    def chunks(self) -> List[Chunk]:
+    def chunks(self) -> list:
         return getattr(self, "_chunks", None)
 
     @property

maxframe/core/graph/__init__.py

@@ -12,6 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .builder import ChunkGraphBuilder, TileableGraphBuilder, TileContext, TileStatus
+from .builder import TileableGraphBuilder
 from .core import DAG, DirectedGraph, GraphContainsCycleError
-from .entity import ChunkGraph, EntityGraph, GraphSerializer, TileableGraph
+from .entity import EntityGraph, GraphSerializer, TileableGraph

maxframe/core/graph/builder/__init__.py

@@ -12,5 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .chunk import ChunkGraphBuilder, TileContext, TileStatus
 from .tileable import TileableGraphBuilder

maxframe/core/graph/builder/base.py

@@ -14,10 +14,10 @@
 
 
 from abc import ABC, abstractmethod
-from typing import Generator, List, Set, Union
+from typing import Generator, List, Set
 
 from ....typing_ import EntityType
-from ..entity import ChunkGraph, EntityGraph, TileableGraph
+from ..entity import EntityGraph
 
 
 def _default_inputs_selector(inputs: List[EntityType]) -> List[EntityType]:
@@ -43,7 +43,7 @@ class AbstractGraphBuilder(ABC):
 
     def _add_nodes(
         self,
-        graph: Union[ChunkGraph, TileableGraph],
+        graph: EntityGraph,
         nodes: List[EntityType],
         visited: Set,
     ):
@@ -75,7 +75,7 @@ class AbstractGraphBuilder(ABC):
                         nodes.append(out)
 
     @abstractmethod
-    def build(self) -> Generator[Union[EntityGraph, ChunkGraph], None, None]:
+    def build(self) -> Generator[EntityGraph, None, None]:
         """
         Build a entity graph.
 
@@ -84,3 +84,4 @@ class AbstractGraphBuilder(ABC):
         graph : EntityGraph
             Entity graph.
         """
+        raise NotImplementedError

maxframe/core/graph/builder/tileable.py

@@ -12,10 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Generator, Union
+from typing import Generator
 
 from ...mode import enter_mode
-from ..entity import ChunkGraph, TileableGraph
+from ..entity import TileableGraph
 from .base import AbstractGraphBuilder
 
 
@@ -26,9 +26,9 @@ class TileableGraphBuilder(AbstractGraphBuilder):
         super().__init__(graph=graph)
 
     @enter_mode(build=True, kernel=True)
-    def _build(self) -> Union[TileableGraph, ChunkGraph]:
+    def _build(self) -> TileableGraph:
         self._add_nodes(self._graph, list(self._graph.result_tileables), set())
         return self._graph
 
-    def build(self) -> Generator[Union[TileableGraph, ChunkGraph], None, None]:
+    def build(self) -> Generator[TileableGraph, None, None]:
         yield self._build()

maxframe/core/graph/builder/utils.py

@@ -13,12 +13,11 @@
 # limitations under the License.
 
 import itertools
-from typing import List, Union
+from typing import List
 
 from ....typing_ import TileableType
 from ...mode import enter_mode
-from ..entity import ChunkGraph, TileableGraph
-from .chunk import ChunkGraphBuilder
+from ..entity import EntityGraph, TileableGraph
 from .tileable import TileableGraphBuilder
 
 
@@ -28,14 +27,11 @@ def build_graph(
     tile: bool = False,
     fuse_enabled: bool = True,
     **chunk_graph_build_kwargs
-) -> Union[TileableGraph, ChunkGraph]:
+) -> EntityGraph:
     tileables = list(itertools.chain(*(tileable.op.outputs for tileable in tileables)))
     tileable_graph = TileableGraph(tileables)
     tileable_graph_builder = TileableGraphBuilder(tileable_graph)
     tileable_graph = next(tileable_graph_builder.build())
     if not tile:
         return tileable_graph
-    chunk_graph_builder = ChunkGraphBuilder(
-        tileable_graph, fuse_enabled=fuse_enabled, **chunk_graph_build_kwargs
-    )
-    return next(chunk_graph_builder.build())
+    raise NotImplementedError

maxframe/core/graph/core.pyx

@@ -354,10 +354,10 @@ cdef class DirectedGraph:
                         sio.write(f'"Chunk:{self._gen_chunk_key(input_chunk, trunc_key)}" {chunk_style}\n')
                         visited.add(input_chunk.key)
                     if op.key not in visited:
-                        sio.write(f'"{op_name}:{op.key[:trunc_key]}" {operator_style}\n')
+                        sio.write(f'"{op_name}:{op.key[:trunc_key]}_{id(op)}" {operator_style}\n')
                         visited.add(op.key)
                     sio.write(f'"Chunk:{self._gen_chunk_key(input_chunk, trunc_key)}" -> '
-                              f'"{op_name}:{op.key[:trunc_key]}"\n')
+                              f'"{op_name}:{op.key[:trunc_key]}_{id(op)}"\n')
 
                 for output_chunk in (op.outputs or []):
                     if output_chunk.key not in visited:
@@ -367,9 +367,9 @@ cdef class DirectedGraph:
                         sio.write(f'"Chunk:{self._gen_chunk_key(output_chunk, trunc_key)}" {tmp_chunk_style}\n')
                         visited.add(output_chunk.key)
                     if op.key not in visited:
-                        sio.write(f'"{op_name}:{op.key[:trunc_key]}" {operator_style}\n')
+                        sio.write(f'"{op_name}:{op.key[:trunc_key]}_{id(op)}" {operator_style}\n')
                         visited.add(op.key)
-                    sio.write(f'"{op_name}:{op.key[:trunc_key]}" -> '
+                    sio.write(f'"{op_name}:{op.key[:trunc_key]}_{id(op)}" -> '
                               f'"Chunk:{self._gen_chunk_key(output_chunk, trunc_key)}"')
                     if show_columns:
                         sio.write(f' [ label={get_col_names(output_chunk)} ]')

maxframe/core/graph/entity.py

@@ -13,9 +13,9 @@
 # limitations under the License.
 
 from abc import ABCMeta, abstractmethod
-from typing import Dict, Iterable, List, Union
+from typing import Dict, Iterable, List
 
-from ...core import Chunk, Tileable
+from ...core import Tileable
 from ...serialization.core import buffered
 from ...serialization.serializables import BoolField, DictField, ListField, Serializable
 from ...serialization.serializables.core import SerializableSerializer
@@ -97,26 +97,6 @@ class TileableGraph(EntityGraph, Iterable[Tileable]):
         return self._logic_key
 
 
-class ChunkGraph(EntityGraph, Iterable[Chunk]):
-    _result_chunks: List[Chunk]
-
-    def __init__(self, result_chunks: List[Chunk] = None):
-        super().__init__()
-        self._result_chunks = result_chunks
-
-    @property
-    def result_chunks(self):
-        return self._result_chunks
-
-    @property
-    def results(self):
-        return self._result_chunks
-
-    @results.setter
-    def results(self, new_results):
-        self._result_chunks = new_results
-
-
 class SerializableGraph(Serializable):
     _is_chunk = BoolField("is_chunk")
     # TODO(qinxuye): remove this logic when we handle fetch elegantly,
@@ -132,12 +112,11 @@ class SerializableGraph(Serializable):
     _results = ListField("results")
 
     @classmethod
-    def from_graph(cls, graph: Union[TileableGraph, ChunkGraph]) -> "SerializableGraph":
+    def from_graph(cls, graph: EntityGraph) -> "SerializableGraph":
         from ..operator import Fetch
 
-        is_chunk = isinstance(graph, ChunkGraph)
         return SerializableGraph(
-            _is_chunk=is_chunk,
+            _is_chunk=False,
             _fetch_nodes=[chunk for chunk in graph if isinstance(chunk.op, Fetch)],
             _nodes=graph._nodes,
             _predecessors=graph._predecessors,
@@ -145,9 +124,8 @@ class SerializableGraph(Serializable):
             _results=graph.results,
         )
 
-    def to_graph(self) -> Union[TileableGraph, ChunkGraph]:
-        graph_cls = ChunkGraph if self._is_chunk else TileableGraph
-        graph = graph_cls(self._results)
+    def to_graph(self) -> EntityGraph:
+        graph = TileableGraph(self._results)
         graph._nodes.update(self._nodes)
         graph._predecessors.update(self._predecessors)
         graph._successors.update(self._successors)
@@ -156,14 +134,12 @@ class SerializableGraph(Serializable):
 
 class GraphSerializer(SerializableSerializer):
     @buffered
-    def serial(self, obj: Union[TileableGraph, ChunkGraph], context: Dict):
+    def serial(self, obj: EntityGraph, context: Dict):
         serializable_graph = SerializableGraph.from_graph(obj)
         return [], [serializable_graph], False
 
-    def deserial(
-        self, serialized: List, context: Dict, subs: List
-    ) -> Union[TileableGraph, ChunkGraph]:
-        serializable_graph: SerializableGraph = subs[0]
+    def deserial(self, serialized: List, context: Dict, subs: List) -> TileableGraph:
+        serializable_graph: EntityGraph = subs[0]
         return serializable_graph.to_graph()
 
 

maxframe/core/operator/__init__.py

@@ -22,13 +22,6 @@ from .base import (
 )
 from .core import TileableOperatorMixin, estimate_size, execute
 from .fetch import Fetch, FetchMixin, FetchShuffle, ShuffleFetchType
-from .fuse import Fuse, FuseChunkMixin
-from .objects import (
-    MergeDictOperator,
-    ObjectFetch,
-    ObjectFuseChunk,
-    ObjectFuseChunkMixin,
-    ObjectOperator,
-    ObjectOperatorMixin,
-)
+from .objects import MergeDictOperator, ObjectFetch, ObjectOperator, ObjectOperatorMixin
 from .shuffle import MapReduceOperator, ShuffleProxy
+from .utils import add_fetch_builder, build_fetch

maxframe/core/operator/base.py

@@ -12,11 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import functools
 import weakref
 from copy import deepcopy
 from enum import Enum
-from functools import partial
+from functools import lru_cache, partial
 from typing import Any, Dict, List, Optional, Tuple, Type, Union
 
 from ...serialization.core import Placeholder
@@ -37,7 +36,6 @@ from ...serialization.serializables.core import SerializableSerializer
 from ...typing_ import OperatorType
 from ...utils import AttributeDict, classproperty, get_user_call_point, tokenize
 from ..base import Base
-from ..entity.chunks import Chunk
 from ..entity.core import ENTITY_TYPE, Entity, EntityData
 from ..entity.output_types import OutputType
 from ..entity.tileables import Tileable
@@ -90,7 +88,7 @@ class SchedulingHint(Serializable):
     priority = Int32Field("priority", default=None)
 
     @classproperty
-    @functools.lru_cache(1)
+    @lru_cache(1)
     def all_hint_names(cls):
         return list(cls._FIELDS)
 
@@ -341,7 +339,7 @@ class Operator(Base, OperatorLogicKeyGeneratorMixin, metaclass=OperatorMetaclass
             raise ValueError("Outputs' size exceeds limitation")
 
     @property
-    def outputs(self) -> List[Union[Chunk, Tileable]]:
+    def outputs(self) -> List[Tileable]:
         outputs = self._outputs
         if outputs:
             return [ref() for ref in outputs]

maxframe/core/operator/objects.py

@@ -17,7 +17,6 @@ from ..entity import OutputType, register_fetch_class
 from .base import Operator
 from .core import TileableOperatorMixin
 from .fetch import Fetch, FetchMixin
-from .fuse import Fuse, FuseChunkMixin
 
 
 class ObjectOperator(Operator):
@@ -28,14 +27,6 @@ class ObjectOperatorMixin(TileableOperatorMixin):
     _output_type_ = OutputType.object
 
 
-class ObjectFuseChunkMixin(FuseChunkMixin, ObjectOperatorMixin):
-    __slots__ = ()
-
-
-class ObjectFuseChunk(ObjectFuseChunkMixin, Fuse):
-    pass
-
-
 class ObjectFetch(FetchMixin, ObjectOperatorMixin, Fetch):
     _output_type_ = OutputType.object
 

maxframe/core/operator/utils.py

@@ -0,0 +1,55 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ...typing_ import EntityType, TileableType
+from ..entity import TILEABLE_TYPE
+
+
+def build_fetch_tileable(tileable: TileableType) -> TileableType:
+    if tileable.is_coarse():
+        chunks = None
+    else:
+        chunks = []
+        for c in tileable.chunks:
+            fetch_chunk = build_fetch(c, index=c.index)
+            chunks.append(fetch_chunk)
+
+    tileable_op = tileable.op
+    params = tileable.params.copy()
+
+    new_op = tileable_op.get_fetch_op_cls(tileable)(_id=tileable_op.id)
+    return new_op.new_tileables(
+        None,
+        chunks=chunks,
+        nsplits=tileable.nsplits,
+        _key=tileable.key,
+        _id=tileable.id,
+        **params,
+    )[0]
+
+
+_type_to_builder = [
+    (TILEABLE_TYPE, build_fetch_tileable),
+]
+
+
+def build_fetch(entity: EntityType, **kw) -> EntityType:
+    for entity_types, func in _type_to_builder:
+        if isinstance(entity, entity_types):
+            return func(entity, **kw)
+    raise TypeError(f"Type {type(entity)} not supported")
+
+
+def add_fetch_builder(entity_type, builder_func):
+    _type_to_builder.append((entity_type, builder_func))

maxframe/dataframe/__init__.py

@@ -54,7 +54,7 @@ from .reduction import CustomReduction, unique
 from .tseries.to_datetime import to_datetime
 
 try:
-    from pandas import NA, Timestamp
+    from pandas import NA, NaT, Timestamp
 except ImportError:  # pragma: no cover
     pass
 

maxframe/dataframe/arithmetic/around.py

@@ -43,20 +43,20 @@ def around(df, decimals=0, *args, **kwargs):
     return op(df)
 
 
+# FIXME Series input of decimals not supported yet
 around.__frame_doc__ = """
 Round a DataFrame to a variable number of decimal places.
 
 Parameters
 ----------
-decimals : int, dict, Series
+decimals : int, dict
     Number of decimal places to round each column to. If an int is
     given, round each column to the same number of places.
     Otherwise dict and Series round to variable numbers of places.
     Column names should be in the keys if `decimals` is a
-    dict-like, or in the index if `decimals` is a Series. Any
-    columns not included in `decimals` will be left as is. Elements
-    of `decimals` which are not columns of the input will be
-    ignored.
+    dict-like. Any columns not included in `decimals` will be left
+    as is. Elements of `decimals` which are not columns of the
+    input will be ignored.
 *args
     Additional keywords have no effect but might be accepted for
     compatibility with numpy.
@@ -107,18 +107,6 @@ places as value
 1   0.0   1.0
 2   0.7   0.0
 3   0.2   0.0
-
-Using a Series, the number of places for specific columns can be
-specified with the column names as index and the number of
-decimal places as value
-
->>> decimals = md.Series([0, 1], index=['cats', 'dogs'])
->>> df.round(decimals).execute()
-    dogs  cats
-0   0.2   0.0
-1   0.0   1.0
-2   0.7   0.0
-3   0.2   0.0
 """
 around.__series_doc__ = """
 Round each value in a Series to the given number of decimals.

maxframe/dataframe/arithmetic/core.py

@@ -39,7 +39,7 @@ class DataFrameBinOpMixin(DataFrameOperatorMixin):
         raise NotImplementedError
 
     @classmethod
-    def _calc_properties(cls, x1, x2=None, axis="columns"):
+    def _calc_properties(cls, x1, x2=None, axis="columns", level=None):
         if isinstance(x1, DATAFRAME_TYPE) and (
             x2 is None or pd.api.types.is_scalar(x2) or isinstance(x2, TENSOR_TYPE)
         ):
@@ -108,7 +108,9 @@ class DataFrameBinOpMixin(DataFrameOperatorMixin):
                     index = copy.copy(x1.index_value)
                     index_shape = x1.shape[0]
                 else:
-                    index = infer_index_value(x1.index_value, x2.index_value)
+                    index = infer_index_value(
+                        x1.index_value, x2.index_value, level=level
+                    )
                     if index.key == x1.index_value.key == x2.index_value.key and (
                         not np.isnan(x1.shape[0]) or not np.isnan(x2.shape[0])
                     ):
@@ -141,7 +143,9 @@ class DataFrameBinOpMixin(DataFrameOperatorMixin):
                         column_shape = len(dtypes)
                     else:  # pragma: no cover
                         dtypes = x1.dtypes  # FIXME
-                        columns = infer_index_value(x1.columns_value, x2.index_value)
+                        columns = infer_index_value(
+                            x1.columns_value, x2.index_value, level=level
+                        )
                         column_shape = np.nan
             else:
                 assert axis == "index" or axis == 0
@@ -169,7 +173,9 @@ class DataFrameBinOpMixin(DataFrameOperatorMixin):
                                 ],
                                 index=x1.dtypes.index,
                             )
-                        index = infer_index_value(x1.index_value, x2.index_value)
+                        index = infer_index_value(
+                            x1.index_value, x2.index_value, level=level
+                        )
                         index_shape = np.nan
             return {
                 "shape": (index_shape, column_shape),
@@ -187,7 +193,9 @@ class DataFrameBinOpMixin(DataFrameOperatorMixin):
                     index = copy.copy(x1.index_value)
                     index_shape = x1.shape[0]
                 else:
-                    index = infer_index_value(x1.index_value, x2.index_value)
+                    index = infer_index_value(
+                        x1.index_value, x2.index_value, level=level
+                    )
                     if index.key == x1.index_value.key == x2.index_value.key and (
                         not np.isnan(x1.shape[0]) or not np.isnan(x2.shape[0])
                     ):
@@ -237,14 +245,14 @@ class DataFrameBinOpMixin(DataFrameOperatorMixin):
         self._check_inputs(x1, x2)
         if isinstance(x1, DATAFRAME_TYPE) or isinstance(x2, DATAFRAME_TYPE):
             df1, df2 = (x1, x2) if isinstance(x1, DATAFRAME_TYPE) else (x2, x1)
-            kw = self._calc_properties(df1, df2, axis=self.axis)
+            kw = self._calc_properties(df1, df2, axis=self.axis, level=self.level)
             if not pd.api.types.is_scalar(df2):
                 return self.new_dataframe([x1, x2], **kw)
             else:
                 return self.new_dataframe([df1], **kw)
         if isinstance(x1, SERIES_TYPE) or isinstance(x2, SERIES_TYPE):
             s1, s2 = (x1, x2) if isinstance(x1, SERIES_TYPE) else (x2, x1)
-            kw = self._calc_properties(s1, s2)
+            kw = self._calc_properties(s1, s2, level=self.level)
             if not pd.api.types.is_scalar(s2):
                 return self.new_series([x1, x2], **kw)
             else: