maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/dataframe/accessors/dict_/getitem.py

@@ -0,0 +1,140 @@
+# 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
+
+from .... import opcodes
+from ....serialization.serializables.field import AnyField, BoolField
+from .core import LegacySeriesDictOperator, SeriesDictMethod
+
+
+class SeriesDictGetItemOperator(LegacySeriesDictOperator):
+    # operator class deprecated since v2.3.0
+    _op_type_ = opcodes.SERIES_DICT_GETITEM
+    _method_name = "getitem"
+    query_key = AnyField("query_key", default=None)
+    default_value = AnyField("default_value", default=None)
+    ignore_key_error = BoolField("ignore_key_error", default=False)
+
+
+def series_dict_getitem(series, query_key, default_value=None):
+    """
+    Get the value by the key of each dict in the Series.
+
+    Parameters
+    ----------
+    query_key : Any
+        The key to check, must be in the same key type of the dict.
+    default_value : Any, optional
+        The value to return if the key is not in the dict, by default None.
+
+    Returns
+    -------
+    Series :
+        A Series with the dict value's data type. The value will be ``default_value``
+        if the key is not in the dict, or ``None`` if the dict is None.
+
+    See Also
+    --------
+    Series.dict.__getitem__: Get the value by the key of each dict in the Series.
+
+    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=dict_(pa.string(), pa.int64()),
+    ... )
+    >>> s.execute()
+    1    [('k1', 1), ('k2', 2)]
+    2               [('k1', 3)]
+    3                      <NA>
+    dtype: map<string, int64>[pyarrow]
+
+    >>> s.dict.get("k2", 9).execute()
+    1       2
+    2       9
+    3    <NA>
+    Name: k2, dtype: int64[pyarrow]
+    """
+    method_kw = dict(
+        query_key=query_key, default_value=default_value, ignore_key_error=True
+    )
+    arrow_map_type = series.dtype.pyarrow_dtype
+    dtype = pd.ArrowDtype(arrow_map_type.item_type)
+    return SeriesDictMethod(method="getitem", method_kwargs=method_kw)(
+        series, name=str(query_key), dtype=dtype
+    )
+
+
+def series_dict_getitem_with_key_error(series, query_key):
+    """
+    Get the value by the key of each dict in the Series. If the key is not in the dict,
+    raise KeyError.
+
+    Parameters
+    ----------
+    query_key : Any
+        The key to check, must be in the same key type of the dict.
+
+    Returns
+    -------
+    Series :
+        A Series with the dict value's data type. Return ``None`` if the dict is None.
+
+    Raises
+    ------
+    KeyError
+        If the key is not in one dict.
+
+    See Also
+    --------
+    Series.dict.get: Get the value by the key of each dict in the Series with an optional
+    default value.
+
+    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=dict_(pa.string(), pa.int64()),
+    ... )
+    >>> s.execute()
+    1    [('k1', 1), ('k2', 2)]
+    2               [('k1', 3)]
+    3                      <NA>
+    dtype: map<string, int64>[pyarrow]
+
+    >>> s.dict["k1"].execute()
+    1       1
+    2       3
+    3    <NA>
+    Name: k1, dtype: int64[pyarrow]
+    """
+    method_kw = dict(query_key=query_key, default_value=None, ignore_key_error=False)
+    arrow_map_type = series.dtype.pyarrow_dtype
+    dtype = pd.ArrowDtype(arrow_map_type.item_type)
+    return SeriesDictMethod(method="getitem", method_kwargs=method_kw)(
+        series, name=str(query_key), dtype=dtype
+    )

maxframe/dataframe/accessors/dict_/length.py

@@ -0,0 +1,64 @@
+# 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 .core import LegacySeriesDictOperator, SeriesDictMethod
+
+
+class SeriesDictLengthOperator(LegacySeriesDictOperator):
+    # operator class deprecated since v2.3.0
+    _op_type_ = opcodes.SERIES_DICT_LENGTH
+    _method_name = "len"
+
+
+def series_dict_length(series):
+    """
+    Get the length of each dict of the Series.
+
+    Returns
+    -------
+    Series :
+        A Series with data type ``pandas.ArrowDtype(pyarrow.int64)``. Each element
+        represents the length of the dict, 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.len().execute()
+    1       2
+    2       1
+    3    <NA>
+    dtype: int64[pyarrow]
+    """
+    return SeriesDictMethod(method="len")(
+        series, name=None, dtype=pd.ArrowDtype(pa.int64())
+    )

maxframe/dataframe/accessors/dict_/remove.py

@@ -0,0 +1,75 @@
+# 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 ....serialization.serializables.field import AnyField, BoolField
+from .core import LegacySeriesDictOperator, SeriesDictMethod
+
+
+class SeriesDictRemoveOperator(LegacySeriesDictOperator):
+    # operator class deprecated since v2.3.0
+    _op_type_ = opcodes.SERIES_DICT_REMOVE
+    _method_name = "remove"
+    query_key = AnyField("query_key", default=None)
+    ignore_key_error = BoolField("ignore_key_error", default=False)
+
+
+def series_dict_remove(series, query_key, ignore_key_error: bool = False):
+    """
+    Remove the item by the key from each dict of the Series.
+
+    Parameters
+    ----------
+    query_key : Any
+        The key to remove, must be in the same key type of the dict.
+    ignore_key_error : bool, optional, default False
+        When the ``query_key`` is not in the dict, if ``ignore_key_error`` is True,
+        nothing will happen in the dict. If ``ignore_key_error`` is ``False``, an
+        ``KeyError`` will be raised. If the dict is ``None``, returns ``None``.
+
+    Returns
+    -------
+    Series :
+        A Series with the same data type. If the dict is ``None``.
+    Raises
+    -------
+    KeyError :
+        If the ``query_key`` is not in one dict and ``ignore_key_error`` is ``False``.
+
+    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.remove("k2", ignore_key_error=True).execute()
+    1    [('k1', 1)]
+    2    [('k1', 3)]
+    3           <NA>
+    dtype: map<string, int64>[pyarrow]
+    """
+    method_kwargs = dict(query_key=query_key, ignore_key_error=ignore_key_error)
+    return SeriesDictMethod(method="remove", method_kwargs=method_kwargs)(series)

maxframe/dataframe/accessors/dict_/setitem.py

@@ -0,0 +1,79 @@
+# 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 ....serialization.serializables.field import AnyField
+from ...core import TILEABLE_TYPE
+from .core import LegacySeriesDictOperator, SeriesDictMethod
+
+
+class SeriesDictSetItemOperator(LegacySeriesDictOperator):
+    # operator class deprecated since v2.3.0
+    _op_type_ = opcodes.SERIES_DICT_SETITEM
+    _method_name = "setitem"
+    query_key = AnyField("query_key", default=None)
+    value = AnyField("default_value", default=None)
+
+
+def series_dict_setitem(series, query_key, value):
+    """
+    Set the value with the key to each dict of the Series.
+
+    Parameters
+    ----------
+    query_key : Any
+        The key of the value to set to, must be in the same key type of the dict.
+    value : Any
+        The value to set, must be in the same value type of the dict. If the ``query_key``
+        exists, the value will be replaced. Otherwise, the value will be added. A dict
+        will be skipped if it's ``None``.
+
+    Returns
+    -------
+    Series :
+        A Series with the same data type.
+
+
+    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=dict_(pa.string(), pa.int64()),
+    ... )
+    >>> s.execute()
+    1    [('k1', 1), ('k2', 2)]
+    2               [('k1', 3)]
+    3                      <NA>
+    dtype: map<string, int64>[pyarrow]
+
+    >>> s.dict["k2"] = 4
+    >>> s.execute()
+    1    [('k1', 1), ('k2', 4)]
+    2    [('k1', 3), ('k2', 4)]
+    3                      <NA>
+    dtype: map<string, int64>[pyarrow]
+    """
+    if isinstance(value, TILEABLE_TYPE):
+        raise NotImplementedError(
+            "Set the value with a dataframe/series is not allowed yet"
+        )
+    method_kwargs = dict(query_key=query_key, value=value)
+    new_series = SeriesDictMethod(method="setitem", method_kwargs=method_kwargs)(series)
+    series.data = new_series.data

maxframe/dataframe/accessors/dict_/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/dict_/tests/test_dict_accessor.py

@@ -0,0 +1,168 @@
+# 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 numpy as np
+import pandas as pd
+import pyarrow as pa
+import pytest
+
+from ..... import dataframe as md
+from .....core import OutputType, TileableGraph, build_fetch
+from .....lib.dtypes_extension import dict_
+from .....utils import (
+    ARROW_DTYPE_NOT_SUPPORTED,
+    deserialize_serializable,
+    serialize_serializable,
+)
+from ..core import SeriesDictMethod
+from ..getitem import SeriesDictGetItemOperator
+
+pytestmark = pytest.mark.skipif(
+    ARROW_DTYPE_NOT_SUPPORTED, reason="Arrow Dtype is not supported"
+)
+
+
+@pytest.fixture
+def df():
+    return md.DataFrame(
+        {
+            "A": pd.Series(
+                [(("k1", "v1"), ("k2", "v2"))], dtype=dict_(pa.string(), pa.string())
+            ),
+            "B": pd.Series([{"k1": 1, "k2": 2}], dtype=dict_(pa.string(), pa.int64())),
+            "C": pd.Series([1], dtype=np.dtype("int64")),
+        },
+        index=[1],
+    )
+
+
+def test_invalid_dtype(df):
+    with pytest.raises(AttributeError):
+        df["C"].dict.contains("k1")
+
+
+def test_getitem(df):
+    s1 = df["A"].dict["k1"]
+    assert isinstance(s1, md.Series)
+    assert s1.name == "k1"
+    assert s1.dtype == pd.ArrowDtype(pa.string())
+    assert s1.shape == (1,)
+    assert s1.index_value == df.index_value
+    op = s1.op
+    assert isinstance(op, SeriesDictMethod)
+    assert op.method == "getitem"
+    assert op.method_kwargs["query_key"] == "k1"
+    assert op.method_kwargs["default_value"] is None
+    assert op.method_kwargs["ignore_key_error"] is False
+
+
+def test_getitem_with_default_value(df):
+    s1 = df["B"].dict.get("k1", 1)
+    assert isinstance(s1, md.Series)
+    assert s1.name == "k1"
+    assert s1.dtype == pd.ArrowDtype(pa.int64())
+    assert s1.shape == (1,)
+    assert s1.index_value == df.index_value
+    op = s1.op
+    assert isinstance(op, SeriesDictMethod)
+    assert op.method == "getitem"
+    assert op.method_kwargs["query_key"] == "k1"
+    assert op.method_kwargs["default_value"] == 1
+    assert op.method_kwargs["ignore_key_error"] is True
+
+
+def test_setitem(df):
+    s1 = df["A"]
+    s1.dict["k1"] = "v3"
+    assert isinstance(s1, md.Series)
+    assert s1.name == "A"
+    assert s1.dtype == dict_(pa.string(), pa.string())
+    assert s1.index_value == df.index_value
+    assert s1.shape == (1,)
+    op = s1.op
+    assert isinstance(op, SeriesDictMethod)
+    assert op.method == "setitem"
+    assert op.method_kwargs["query_key"] == "k1"
+    assert op.method_kwargs["value"] == "v3"
+
+
+def test_length(df):
+    s1 = df["A"].dict.len()
+    assert isinstance(s1, md.Series)
+    assert s1.name is None
+    assert s1.dtype == pd.ArrowDtype(pa.int64())
+    assert s1.shape == (1,)
+    assert s1.index_value == df.index_value
+    op = s1.op
+    assert op.method == "len"
+    assert isinstance(op, SeriesDictMethod)
+
+
+def test_remove(df):
+    s1 = df["A"].dict.remove("k1", ignore_key_error=True)
+    assert isinstance(s1, md.Series)
+    assert s1.name == "A"
+    assert s1.dtype == dict_(pa.string(), pa.string())
+    assert s1.index_value == df.index_value
+    assert s1.shape == (1,)
+    op = s1.op
+    assert isinstance(op, SeriesDictMethod)
+    assert op.method == "remove"
+    assert op.method_kwargs["query_key"] == "k1"
+    assert op.method_kwargs["ignore_key_error"] is True
+
+
+def test_contains(df):
+    s1 = df["A"].dict.contains("k1")
+    assert isinstance(s1, md.Series)
+    assert s1.name is None
+    assert s1.dtype == pd.ArrowDtype(pa.bool_())
+    assert s1.index_value == df.index_value
+    assert s1.shape == (1,)
+    op = s1.op
+    assert isinstance(op, SeriesDictMethod)
+    assert op.method == "contains"
+    assert op.method_kwargs["query_key"] == "k1"
+
+
+def test_legacy_compatibility(df):
+    in_series = df["A"]
+    legacy_op = SeriesDictGetItemOperator(
+        query_key="k1",
+        default_value=1,
+        ignore_key_error=True,
+        _output_types=[OutputType.series],
+    )
+    out = legacy_op.new_tileable(
+        [in_series],
+        shape=in_series.shape,
+        index_value=in_series.index_value,
+        name="k1",
+        dtype=pd.ArrowDtype(pa.int64()),
+    )
+    fetch_node = build_fetch(in_series).data
+    out.op.inputs = [fetch_node]
+
+    dag = TileableGraph([out.data])
+    dag.add_node(fetch_node)
+    dag.add_node(out.data)
+    dag.add_edge(fetch_node, out.data)
+    dag_out = deserialize_serializable(serialize_serializable(dag))
+
+    out_op = dag_out.results[0].op
+    assert isinstance(out_op, SeriesDictMethod)
+    assert out_op.method == "getitem"
+    assert out_op.method_kwargs["ignore_key_error"] == True
+    assert out_op.method_kwargs["default_value"] == 1
+    assert out_op.method_kwargs["query_key"] == "k1"

maxframe/dataframe/accessors/list_/__init__.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 .core import SeriesListMethod
+
+
+def _install():
+    from ....core import CachedAccessor
+    from ...core import SERIES_TYPE
+    from .accessor import ListAccessor
+    from .getitem import series_list_getitem, series_list_getitem_with_index_error
+    from .length import series_list_length
+
+    list_method_to_handlers = {
+        "__getitem__": series_list_getitem_with_index_error,
+        "get": series_list_getitem,
+        "len": series_list_length,
+    }
+
+    for name, handler in list_method_to_handlers.items():
+        ListAccessor._register(name, handler)
+
+    for series in SERIES_TYPE:
+        series.list = CachedAccessor("list", ListAccessor)
+
+
+_install()
+del _install

maxframe/dataframe/accessors/list_/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 ListAccessor(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.ListType
+        ):
+            raise AttributeError("Can only use .list accessor with list values")

maxframe/dataframe/accessors/list_/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 SeriesListMethod(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.SERIES_LIST_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 LegacySeriesListOperator(LegacySeriesMethodOperator):
+    _method_cls = SeriesListMethod