maxframe 1.1.1__cp37-cp37m-win32.whl → 1.2.1__cp37-cp37m-win32.whl

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,43 @@
+# 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.
+
+
+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,38 @@
+# 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,81 @@
+# 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.entity.output_types import OutputType
+from ....serialization.serializables.field import AnyField
+from ...operators import DataFrameOperator, DataFrameOperatorMixin
+
+
+class SeriesDictContainsOperator(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.SERIES_DICT_CONTAINS
+    query_key = AnyField("query_key", default=None)
+
+    def __init__(self, **kw):
+        super().__init__(_output_types=[OutputType.series], **kw)
+
+    def __call__(self, series):
+        return self.new_series(
+            [series],
+            shape=series.shape,
+            dtype=pd.ArrowDtype(pa.bool_()),
+            index_value=series.index_value,
+            name=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 SeriesDictContainsOperator(query_key=query_key)(series)

maxframe/dataframe/accessors/dict_/getitem.py

@@ -0,0 +1,144 @@
+# 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 ....core.entity.output_types import OutputType
+from ....serialization.serializables.field import AnyField, BoolField
+from ...operators import DataFrameOperator, DataFrameOperatorMixin
+
+
+class SeriesDictGetItemOperator(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.SERIES_DICT_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 __init__(self, **kw):
+        super().__init__(_output_types=[OutputType.series], **kw)
+
+    def __call__(self, series):
+        arrow_map_type = series.dtype.pyarrow_dtype
+        return self.new_series(
+            [series],
+            shape=series.shape,
+            dtype=pd.ArrowDtype(arrow_map_type.item_type),
+            index_value=series.index_value,
+            name=str(self.query_key),
+        )
+
+
+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]
+    """
+    return SeriesDictGetItemOperator(
+        query_key=query_key, default_value=default_value, ignore_key_error=True
+    )(series)
+
+
+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]
+    """
+    return SeriesDictGetItemOperator(
+        query_key=query_key, default_value=None, ignore_key_error=False
+    )(series)

maxframe/dataframe/accessors/dict_/length.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 ....core.entity.output_types import OutputType
+from ...operators import DataFrameOperator, DataFrameOperatorMixin
+
+
+class SeriesDictLengthOperator(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.SERIES_DICT_LENGTH
+
+    def __init__(self, **kw):
+        super().__init__(_output_types=[OutputType.series], **kw)
+
+    def __call__(self, series):
+        return self.new_series(
+            [series],
+            shape=series.shape,
+            index_value=series.index_value,
+            dtype=pd.ArrowDtype(pa.int64()),
+            name=None,
+        )
+
+
+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 SeriesDictLengthOperator()(series)

maxframe/dataframe/accessors/dict_/remove.py

@@ -0,0 +1,87 @@
+# 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.entity.output_types import OutputType
+from ....serialization.serializables.field import AnyField, BoolField
+from ...operators import DataFrameOperator, DataFrameOperatorMixin
+
+
+class SeriesDictRemoveOperator(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.SERIES_DICT_REMOVE
+    query_key = AnyField("query_key", default=None)
+    ignore_key_error = BoolField("ignore_key_error", default=False)
+
+    def __init__(self, **kw):
+        super().__init__(_output_types=[OutputType.series], **kw)
+
+    def __call__(self, series):
+        return self.new_series(
+            [series],
+            shape=series.shape,
+            index_value=series.index_value,
+            dtype=series.dtype,
+            name=series.name,
+        )
+
+
+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]
+    """
+    return SeriesDictRemoveOperator(
+        query_key=query_key, ignore_key_error=ignore_key_error
+    )(series)

maxframe/dataframe/accessors/dict_/setitem.py

@@ -0,0 +1,88 @@
+# 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.entity.output_types import OutputType
+from ....serialization.serializables.field import AnyField
+from ...core import TILEABLE_TYPE
+from ...operators import DataFrameOperator, DataFrameOperatorMixin
+
+
+class SeriesDictSetItemOperator(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.SERIES_DICT_SETITEM
+    query_key = AnyField("query_key", default=None)
+    value = AnyField("default_value", default=None)
+
+    def __init__(self, **kw):
+        super().__init__(_output_types=[OutputType.series], **kw)
+
+    def __call__(self, series):
+        new_series = self.new_series(
+            [series],
+            shape=series.shape,
+            index_value=series.index_value,
+            dtype=series.dtype,
+            name=series.name,
+        )
+        series.data = new_series.data
+
+
+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=map_(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"
+        )
+    return SeriesDictSetItemOperator(query_key=query_key, value=value)(series)

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.