maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/dataframe/__init__.py

@@ -0,0 +1,90 @@
+# Copyright 1999-2025 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 . import (
+    accessors,
+    arithmetic,
+    datasource,
+    datastore,
+    extensions,
+    fetch,
+    groupby,
+    indexing,
+    merge,
+    misc,
+    missing,
+    reduction,
+    sort,
+    statistics,
+    tseries,
+    ufunc,
+    window,
+)
+from .datasource.date_range import date_range
+from .datasource.direct import read_clipboard
+from .datasource.from_index import series_from_index
+from .datasource.from_records import from_records
+from .datasource.from_tensor import dataframe_from_tensor, series_from_tensor
+from .datasource.read_csv import read_csv
+from .datasource.read_odps_query import read_odps_query
+from .datasource.read_odps_table import read_odps_table
+from .datasource.read_parquet import read_parquet
+from .datastore.to_odps import to_odps_table
+from .initializer import DataFrame, Index, Series, read_pandas
+from .merge import concat, merge
+from .misc.cut import cut
+from .misc.eval import maxframe_eval as eval  # pylint: disable=redefined-builtin
+from .misc.factorize import factorize
+from .misc.get_dummies import get_dummies
+from .misc.qcut import qcut
+from .misc.to_numeric import to_numeric
+from .missing import isna, isnull, notna, notnull
+from .reduction import CustomReduction, NamedAgg, unique
+from .reshape.melt import melt
+from .reshape.pivot import pivot
+from .reshape.pivot_table import pivot_table
+from .tseries.to_datetime import to_datetime
+
+try:
+    from pandas import NA, NaT, Timestamp
+except ImportError:  # pragma: no cover
+    pass
+
+try:
+    from . import _internal
+except ImportError:  # pragma: no cover
+    pass
+
+del (
+    accessors,
+    arithmetic,
+    datasource,
+    datastore,
+    extensions,
+    fetch,
+    groupby,
+    indexing,
+    reduction,
+    sort,
+    tseries,
+    ufunc,
+)
+
+from_pandas = read_pandas
+
+# isort: off
+from .typing_ import register_pandas_typing_funcs
+
+register_pandas_typing_funcs()
+del register_pandas_typing_funcs

maxframe/dataframe/accessors/__init__.py

@@ -0,0 +1,20 @@
+# Copyright 1999-2025 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 . import plotting
+from .datetime_ import SeriesDatetimeMethod
+from .dict_ import SeriesDictMethod
+from .list_ import SeriesListMethod
+from .string_ import SeriesStringMethod
+from .struct_ import SeriesStructMethod

maxframe/dataframe/accessors/compat.py

@@ -0,0 +1,45 @@
+# Copyright 1999-2025 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.
+
+import logging
+
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+
+logger = logging.getLogger(__name__)
+
+
+class LegacySeriesMethodOperator(DataFrameOperator, DataFrameOperatorMixin):
+    _method_name = None
+    _method_cls = None
+
+    def __on_deserialize__(self):
+        cls = type(self)
+        local_fields = {
+            f
+            for f, name_hash in cls._FIELD_TO_NAME_HASH.items()
+            if name_hash == cls._NAME_HASH
+        }
+        kw = {
+            f: getattr(self, f)
+            for f in cls._FIELD_TO_NAME_HASH
+            if f not in local_fields and hasattr(self, f)
+        }
+
+        kw["method"] = self._method_name
+        kw["method_kwargs"] = {
+            f: getattr(self, f) for f in local_fields if hasattr(self, f)
+        }
+
+        logger.warning(f"Using deprecated operator class {cls.__name__}")
+        return self._method_cls(**kw)

maxframe/dataframe/accessors/datetime_/__init__.py

@@ -0,0 +1,35 @@
+# Copyright 1999-2025 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 .core import SeriesDatetimeMethod, datetime_method_to_handlers
+
+methods = set(datetime_method_to_handlers.keys())
+del datetime_method_to_handlers
+
+
+def _install():
+    from ....core import CachedAccessor
+    from ...core import SERIES_TYPE
+    from .accessor import DatetimeAccessor
+    from .core import datetime_method_to_handlers
+
+    for method in datetime_method_to_handlers:
+        if not hasattr(DatetimeAccessor, method):
+            DatetimeAccessor._register(method)
+    for series in SERIES_TYPE:
+        series.dt = CachedAccessor("dt", DatetimeAccessor)
+
+
+_install()
+del _install

maxframe/dataframe/accessors/datetime_/accessor.py

@@ -0,0 +1,67 @@
+# Copyright 1999-2025 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 functools import wraps
+from typing import Iterable
+
+import pandas as pd
+from pandas.api.types import (
+    is_datetime64_dtype,
+    is_datetime64tz_dtype,
+    is_period_dtype,
+    is_timedelta64_dtype,
+)
+
+from ....utils import adapt_docstring
+from .core import SeriesDatetimeMethod, datetime_method_to_handlers
+
+
+class DatetimeAccessor:
+    def __init__(self, series):
+        if (
+            not is_datetime64_dtype(series.dtype)
+            and not is_datetime64tz_dtype(series.dtype)
+            and not is_timedelta64_dtype(series.dtype)
+            and not is_period_dtype(series.dtype)
+        ):
+            raise AttributeError("Can only use .dt accessor with datetimelike values")
+        self._series = series
+
+    @classmethod
+    def _gen_func(cls, method, is_property):
+        @wraps(getattr(pd.Series.dt, method))
+        def _inner(self, *args, **kwargs):
+            op = SeriesDatetimeMethod(
+                method=method,
+                is_property=is_property,
+                method_args=args,
+                method_kwargs=kwargs,
+            )
+            return op(self._series)
+
+        _inner.__doc__ = adapt_docstring(getattr(pd.Series.dt, method).__doc__)
+        return _inner
+
+    @classmethod
+    def _register(cls, method):
+        is_property = not callable(getattr(pd.Series.dt, method))
+        func = cls._gen_func(method, is_property)
+        if is_property:
+            func = property(func)
+        setattr(cls, method, func)
+
+    def __dir__(self) -> Iterable[str]:
+        s = set(super().__dir__())
+        s.update(datetime_method_to_handlers.keys())
+        return list(s)

maxframe/dataframe/accessors/datetime_/core.py

@@ -0,0 +1,106 @@
+# Copyright 1999-2025 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 List
+
+import pandas as pd
+
+from .... import opcodes
+from ....core import EntityData, OutputType
+from ....serialization.serializables import (
+    BoolField,
+    DictField,
+    KeyField,
+    StringField,
+    TupleField,
+)
+from ...operators import DataFrameOperator, DataFrameOperatorMixin
+from ...utils import build_empty_series, parse_index
+
+
+class SeriesDatetimeMethod(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.DATETIME_METHOD
+
+    _input = KeyField("input")
+    method = StringField("method", default=None)
+    method_args = TupleField("method_args", default=None)
+    method_kwargs = DictField("method_kwargs", default=None)
+    is_property = BoolField("is_property", default=None)
+
+    def __init__(self, output_types=None, **kw):
+        super().__init__(_output_types=output_types, **kw)
+        if not self.output_types:
+            self.output_types = [OutputType.series]
+
+    @property
+    def input(self):
+        return self._input
+
+    @classmethod
+    def _set_inputs(cls, op: "SeriesDatetimeMethod", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op._input = op._inputs[0]
+
+    def __call__(self, inp):
+        return datetime_method_to_handlers[self.method].call(self, inp)
+
+
+class SeriesDatetimeMethodBaseHandler:
+    @classmethod
+    def call(cls, op, inp):
+        empty_series = build_empty_series(inp.dtype)
+        if op.is_property:
+            test_obj = getattr(empty_series.dt, op.method)
+        else:
+            test_obj = getattr(empty_series.dt, op.method)(
+                *op.method_args, **op.method_kwargs
+            )
+        dtype = test_obj.dtype
+        return op.new_series(
+            [inp],
+            shape=inp.shape,
+            dtype=dtype,
+            index_value=inp.index_value,
+            name=inp.name,
+        )
+
+
+class SeriesDatetimeIsoCalendarHandler:
+    @classmethod
+    def call(cls, op, inp):
+        empty_series = build_empty_series(inp.dtype)
+        if op.is_property:
+            test_obj = getattr(empty_series.dt, op.method)
+        else:
+            test_obj = getattr(empty_series.dt, op.method)(
+                *op.method_args, **op.method_kwargs
+            )
+        dtypes = test_obj.dtypes
+        return op.new_dataframe(
+            [inp],
+            shape=(inp.shape[0], len(dtypes)),
+            dtypes=dtypes,
+            index_value=inp.index_value,
+            columns_value=parse_index(dtypes.index, store_data=True),
+        )
+
+
+datetime_method_to_handlers = {
+    "isocalendar": SeriesDatetimeIsoCalendarHandler,
+}
+for method in dir(pd.Series.dt):
+    if method in datetime_method_to_handlers:
+        continue
+    if not method.startswith("_"):
+        datetime_method_to_handlers[method] = SeriesDatetimeMethodBaseHandler

maxframe/dataframe/accessors/datetime_/tests/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 1999-2025 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.

maxframe/dataframe/accessors/datetime_/tests/test_datetime_accessor.py

@@ -0,0 +1,41 @@
+# Copyright 1999-2025 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.
+
+import pandas as pd
+import pytest
+
+from .....core import OutputType
+from ....datasource.series import from_pandas as from_pandas_series
+
+
+def test_datetime_method():
+    s = pd.Series(
+        [pd.Timestamp("2020-1-1"), pd.Timestamp("2020-2-1"), pd.Timestamp("2020-3-1")],
+        name="ss",
+    )
+    series = from_pandas_series(s, chunk_size=2)
+
+    r = series.dt.year
+    assert r.dtype == s.dt.year.dtype
+    pd.testing.assert_index_equal(r.index_value.to_pandas(), s.index)
+    assert r.shape == s.shape
+    assert r.op.output_types[0] == OutputType.series
+    assert r.name == s.dt.year.name
+
+    with pytest.raises(AttributeError):
+        _ = from_pandas_series(pd.Series([1])).dt
+    with pytest.raises(AttributeError):
+        _ = series.dt.non_exist
+
+    assert "ceil" in dir(series.dt)

maxframe/dataframe/accessors/dict_/__init__.py

@@ -0,0 +1,45 @@
+# Copyright 1999-2025 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 .core import SeriesDictMethod
+
+
+def _install():
+    from ....core import CachedAccessor
+    from ...core import SERIES_TYPE
+    from .accessor import DictAccessor
+    from .contains import series_dict_contains
+    from .getitem import series_dict_getitem, series_dict_getitem_with_key_error
+    from .length import series_dict_length
+    from .remove import series_dict_remove
+    from .setitem import series_dict_setitem
+
+    dict_method_to_handlers = {
+        "__getitem__": series_dict_getitem_with_key_error,
+        "get": series_dict_getitem,
+        "__setitem__": series_dict_setitem,
+        "len": series_dict_length,
+        "remove": series_dict_remove,
+        "contains": series_dict_contains,
+    }
+
+    for name, handler in dict_method_to_handlers.items():
+        DictAccessor._register(name, handler)
+
+    for series in SERIES_TYPE:
+        series.dict = CachedAccessor("dict", DictAccessor)
+
+
+_install()
+del _install

maxframe/dataframe/accessors/dict_/accessor.py

@@ -0,0 +1,39 @@
+# Copyright 1999-2025 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 TYPE_CHECKING
+
+import pandas as pd
+import pyarrow as pa
+
+from ....core import BaseMaxFrameAccessor
+from ....utils import ARROW_DTYPE_NOT_SUPPORTED
+
+if TYPE_CHECKING:
+    from ...core import Series
+
+
+class DictAccessor(BaseMaxFrameAccessor):
+    obj: "Series"
+    _api_count: int = 0
+
+    def __init__(self, series):
+        super().__init__(series)
+        if ARROW_DTYPE_NOT_SUPPORTED:
+            raise ImportError("pd.ArrowDtype is not supported in current environment")
+
+        if not isinstance(series.dtype, pd.ArrowDtype) or not isinstance(
+            series.dtype.pyarrow_dtype, pa.MapType
+        ):
+            raise AttributeError("Can only use .dict accessor with dict values")

maxframe/dataframe/accessors/dict_/contains.py

@@ -0,0 +1,72 @@
+# Copyright 1999-2025 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.
+
+import pandas as pd
+import pyarrow as pa
+
+from .... import opcodes
+from ....serialization.serializables.field import AnyField
+from .core import LegacySeriesDictOperator, SeriesDictMethod
+
+
+class SeriesDictContainsOperator(LegacySeriesDictOperator):
+    # operator class deprecated since v2.3.0
+    _op_type_ = opcodes.SERIES_DICT_CONTAINS
+    _method_name = "contains"
+    query_key = AnyField("query_key", default=None)
+
+
+def series_dict_contains(series, query_key):
+    """
+    Check whether the key is in each dict of the Series.
+
+    Parameters
+    ----------
+    query_key : Any
+        The key to check, must be in the same key type of the dict.
+
+    Returns
+    -------
+    Series :
+        A Series with data type ``pandas.ArrowDtype(pyarrow.bool_)``. The value will
+        be ``True`` if the key is in the dict, ``False`` otherwise, or ``None`` if the
+        dict is None.
+
+    Examples
+    --------
+    Create a series with dict type data.
+
+    >>> import maxframe.dataframe as md
+    >>> import pyarrow as pa
+    >>> from maxframe.lib.dtypes_extension import dict_
+    >>> s = md.Series(
+    ...     data=[[("k1", 1), ("k2", 2)], [("k1", 3)], None],
+    ...     index=[1, 2, 3],
+    ...     dtype=map_(pa.string(), pa.int64()),
+    ... )
+    >>> s.execute()
+    1    [('k1', 1), ('k2', 2)]
+    2               [('k1', 3)]
+    3                      <NA>
+    dtype: map<string, int64>[pyarrow]
+
+    >>> s.dict.contains("k2").execute()
+    1     True
+    2    False
+    3     <NA>
+    dtype: bool[pyarrow]
+    """
+    return SeriesDictMethod(method="contains", method_kwargs=dict(query_key=query_key))(
+        series, dtype=pd.ArrowDtype(pa.bool_()), name=None
+    )

maxframe/dataframe/accessors/dict_/core.py

@@ -0,0 +1,48 @@
+# Copyright 1999-2025 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 .... import opcodes
+from ....core import OutputType
+from ....serialization.serializables import DictField, StringField, TupleField
+from ....utils import no_default
+from ...operators import DataFrameOperator, DataFrameOperatorMixin
+from ..compat import LegacySeriesMethodOperator
+
+
+class SeriesDictMethod(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.SERIES_DICT_METHOD
+
+    method = StringField("method", default=None)
+    method_args = TupleField("method_args", default_factory=list)
+    method_kwargs = DictField("method_kwargs", default_factory=dict)
+
+    def __init__(self, output_types=None, **kw):
+        output_types = output_types or [OutputType.series]
+        kw["_output_types"] = kw.get("_output_types") or output_types
+        super().__init__(**kw)
+
+    def __call__(self, inp, dtype=None, name=no_default):
+        dtype = dtype or inp.dtype
+        name = inp.name if name is no_default else name
+        return self.new_series(
+            [inp],
+            shape=inp.shape,
+            dtype=dtype,
+            index_value=inp.index_value,
+            name=name,
+        )
+
+
+class LegacySeriesDictOperator(LegacySeriesMethodOperator):
+    _method_cls = SeriesDictMethod