maxframe 0.1.0b5__cp38-cp38-macosx_11_0_arm64.whl

maxframe/dataframe/merge/tests/test_merge.py

@@ -0,0 +1,215 @@
+# 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.
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from ...core import IndexValue
+from ...datasource.dataframe import from_pandas
+from .. import DataFrameMerge, concat
+
+
+def test_merge():
+    df1 = pd.DataFrame(
+        np.arange(20).reshape((4, 5)) + 1, columns=["a", "b", "c", "d", "e"]
+    )
+    df2 = pd.DataFrame(np.arange(20).reshape((5, 4)) + 1, columns=["a", "b", "x", "y"])
+
+    mdf1 = from_pandas(df1, chunk_size=2)
+    mdf2 = from_pandas(df2, chunk_size=3)
+
+    parameters = [
+        {},
+        {"how": "left", "right_on": "x", "left_index": True},
+        {"how": "right", "left_on": "a", "right_index": True},
+        {"how": "left", "left_on": "a", "right_on": "x"},
+        {"how": "right", "left_on": "a", "right_index": True},
+        {"how": "right", "on": "a"},
+        {"how": "inner", "on": ["a", "b"]},
+    ]
+
+    for kw in parameters:
+        df = mdf1.merge(mdf2, **kw)
+
+        assert isinstance(df.op, DataFrameMerge)
+        assert df.op.how == kw.get("how", "inner")
+        pd.testing.assert_index_equal(
+            df.columns_value.to_pandas(), df.columns_value.to_pandas()
+        )
+
+
+def test_merge_invalid_parameters():
+    pdf1 = pd.DataFrame(
+        np.arange(20).reshape((4, 5)) + 1, columns=["a", "b", "c", "d", "e"]
+    )
+    pdf2 = pd.DataFrame(np.arange(20).reshape((5, 4)) + 1, columns=["a", "b", "x", "y"])
+
+    df1 = from_pandas(pdf1, chunk_size=2)
+    df2 = from_pandas(pdf2, chunk_size=3)
+
+    with pytest.raises(ValueError):
+        df1.merge(df2, bloom_filter="wrong")
+
+    with pytest.raises(TypeError):
+        df1.merge(df2, bloom_filter_options="wrong")
+
+    with pytest.raises(ValueError):
+        df1.merge(df2, bloom_filter_options={"wrong": 1})
+
+    with pytest.raises(ValueError):
+        df1.merge(df2, bloom_filter_options={"filter": "wrong"})
+
+
+def test_join():
+    df1 = pd.DataFrame([[1, 3, 3], [4, 2, 6], [7, 8, 9]], index=["a1", "a2", "a3"])
+    df2 = pd.DataFrame([[1, 2, 3], [1, 5, 6], [7, 8, 9]], index=["a1", "b2", "b3"]) + 1
+    df2 = pd.concat([df2, df2 + 1])
+
+    mdf1 = from_pandas(df1, chunk_size=2)
+    mdf2 = from_pandas(df2, chunk_size=2)
+
+    parameters = [
+        {"lsuffix": "l_", "rsuffix": "r_"},
+        {"lsuffix": "l_", "rsuffix": "r_", "how": "left"},
+        {"lsuffix": "l_", "rsuffix": "r_", "how": "right"},
+        {"lsuffix": "l_", "rsuffix": "r_", "how": "inner"},
+        {"lsuffix": "l_", "rsuffix": "r_", "how": "left"},
+    ]
+
+    for kw in parameters:
+        df = mdf1.join(mdf2, auto_merge="none", bloom_filter=False, **kw)
+
+        assert isinstance(df.op, DataFrameMerge)
+        assert df.op.how == kw.get("how", "left")
+        pd.testing.assert_index_equal(
+            df.columns_value.to_pandas(), df.columns_value.to_pandas()
+        )
+
+
+def test_join_on():
+    df1 = pd.DataFrame([[1, 3, 3], [4, 2, 6], [7, 8, 9]], columns=["a1", "a2", "a3"])
+    df2 = (
+        pd.DataFrame([[1, 2, 3], [1, 5, 6], [7, 8, 9]], columns=["a1", "b2", "b3"]) + 1
+    )
+    df2 = pd.concat([df2, df2 + 1])
+
+    mdf1 = from_pandas(df1, chunk_size=2)
+    mdf2 = from_pandas(df2, chunk_size=2)
+
+    parameters = [
+        {"lsuffix": "l_", "rsuffix": "r_"},
+        {"lsuffix": "l_", "rsuffix": "r_", "how": "left", "on": "a1"},
+        {"lsuffix": "l_", "rsuffix": "r_", "how": "right", "on": "a2"},
+        {"lsuffix": "l_", "rsuffix": "r_", "how": "inner", "on": "a2"},
+        {"lsuffix": "l_", "rsuffix": "r_", "how": "outer", "on": "a2"},
+    ]
+
+    for kw in parameters:
+        df = mdf1.join(mdf2, auto_merge="none", bloom_filter=False, **kw)
+
+        assert isinstance(df.op, DataFrameMerge)
+        assert df.op.how == kw.get("how", "left")
+        pd.testing.assert_index_equal(
+            df.columns_value.to_pandas(), df.columns_value.to_pandas()
+        )
+
+
+def test_append():
+    df1 = pd.DataFrame(np.random.rand(10, 4), columns=list("ABCD"))
+    df2 = pd.DataFrame(np.random.rand(10, 4), columns=list("ABCD"))
+
+    mdf1 = from_pandas(df1, chunk_size=3)
+    mdf2 = from_pandas(df2, chunk_size=3)
+    adf = mdf1.append(mdf2)
+
+    assert adf.shape == (20, 4)
+    assert isinstance(adf.index_value.value, IndexValue.Int64Index)
+
+    mdf1 = from_pandas(df1, chunk_size=3)
+    mdf2 = from_pandas(df2, chunk_size=3)
+    adf = mdf1.append(mdf2, ignore_index=True)
+
+    assert adf.shape == (20, 4)
+    assert isinstance(adf.index_value.value, IndexValue.RangeIndex)
+    pd.testing.assert_index_equal(adf.index_value.to_pandas(), pd.RangeIndex(20))
+
+
+def test_concat():
+    df1 = pd.DataFrame(np.random.rand(10, 4), columns=list("ABCD"))
+    df2 = pd.DataFrame(np.random.rand(10, 4), columns=list("ABCD"))
+
+    mdf1 = from_pandas(df1, chunk_size=4)
+    mdf2 = from_pandas(df2, chunk_size=4)
+    r = concat([mdf1, mdf2], axis="index")
+
+    assert r.shape == (20, 4)
+    pd.testing.assert_series_equal(r.dtypes, df1.dtypes)
+
+    df3 = pd.DataFrame(
+        np.random.rand(10, 4), columns=list("ABCD"), index=pd.RangeIndex(10, 20)
+    )
+
+    mdf3 = from_pandas(df3, chunk_size=4)
+    r = concat([mdf1, mdf3], axis="index")
+
+    assert r.shape == (20, 4)
+    pd.testing.assert_series_equal(r.dtypes, df1.dtypes)
+    pd.testing.assert_index_equal(r.index_value.to_pandas(), pd.RangeIndex(20))
+
+    df4 = pd.DataFrame(
+        np.random.rand(10, 4),
+        columns=list("ABCD"),
+        index=np.random.permutation(np.arange(10)),
+    )
+
+    mdf4 = from_pandas(df4, chunk_size=4)
+    r = concat([mdf1, mdf4], axis="index")
+
+    assert r.shape == (20, 4)
+    pd.testing.assert_series_equal(r.dtypes, df1.dtypes)
+    pd.testing.assert_index_equal(
+        r.index_value.to_pandas(), pd.Index([], dtype=np.int64)
+    )
+
+    r = concat([mdf4, mdf1], axis="index")
+
+    assert r.shape == (20, 4)
+    pd.testing.assert_series_equal(r.dtypes, df1.dtypes)
+    pd.testing.assert_index_equal(
+        r.index_value.to_pandas(), pd.Index([], dtype=np.int64)
+    )
+
+    r = concat([mdf4, mdf4], axis="index")
+
+    assert r.shape == (20, 4)
+    pd.testing.assert_series_equal(r.dtypes, df1.dtypes)
+    pd.testing.assert_index_equal(
+        r.index_value.to_pandas(), pd.Index([], dtype=np.int64)
+    )
+
+    mdf1 = from_pandas(df1, chunk_size=3)
+    mdf2 = from_pandas(df2, chunk_size=4)
+    r = concat([mdf1, mdf2], axis="columns")
+
+    assert r.shape == (10, 8)
+    expected_dtypes = pd.concat([df1, df2], axis="columns").dtypes
+    pd.testing.assert_series_equal(r.dtypes, expected_dtypes)
+
+    df1 = pd.DataFrame(np.random.rand(10, 4), columns=list("ABCD"))
+    df2 = pd.DataFrame(np.random.rand(10, 3), columns=list("ABC"))
+    mdf1 = from_pandas(df1, chunk_size=3)
+    mdf2 = from_pandas(df2, chunk_size=3)
+    r = concat([mdf1, mdf2], join="inner")
+    assert r.shape == (20, 3)

maxframe/dataframe/misc/__init__.py

@@ -0,0 +1,134 @@
+# 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 .apply import df_apply, series_apply
+from .astype import astype, index_astype
+from .case_when import case_when
+from .check_monotonic import (
+    check_monotonic,
+    is_monotonic,
+    is_monotonic_decreasing,
+    is_monotonic_increasing,
+)
+from .cut import cut
+from .describe import describe
+from .diff import df_diff, series_diff
+from .drop import df_drop, df_pop, index_drop, series_drop
+from .drop_duplicates import (
+    df_drop_duplicates,
+    index_drop_duplicates,
+    series_drop_duplicates,
+)
+from .duplicated import df_duplicated, index_duplicated, series_duplicated
+from .eval import df_eval, df_query
+from .explode import df_explode, series_explode
+from .isin import df_isin, series_isin
+from .map import index_map, series_map
+from .melt import melt
+from .memory_usage import df_memory_usage, index_memory_usage, series_memory_usage
+from .pct_change import pct_change
+from .pivot_table import pivot_table
+from .qcut import qcut
+from .select_dtypes import select_dtypes
+from .shift import shift, tshift
+from .stack import stack
+from .transform import df_transform, series_transform
+from .transpose import transpose
+from .value_counts import value_counts
+
+
+def _install():
+    from ..core import DATAFRAME_TYPE, INDEX_TYPE, SERIES_TYPE
+    from .accessor import CachedAccessor, DatetimeAccessor, StringAccessor
+    from .datetimes import _datetime_method_to_handlers
+    from .string_ import _string_method_to_handlers
+
+    for t in DATAFRAME_TYPE:
+        setattr(t, "apply", df_apply)
+        setattr(t, "astype", astype)
+        setattr(t, "describe", describe)
+        setattr(
+            t, "__delitem__", lambda df, items: df_drop(df, items, axis=1, inplace=True)
+        )
+        setattr(t, "diff", df_diff)
+        setattr(t, "drop_duplicates", df_drop_duplicates)
+        setattr(t, "duplicated", df_duplicated)
+        setattr(t, "drop", df_drop)
+        setattr(t, "eval", df_eval)
+        setattr(t, "explode", df_explode)
+        setattr(t, "isin", df_isin)
+        setattr(t, "melt", melt)
+        setattr(t, "memory_usage", df_memory_usage)
+        setattr(t, "pct_change", pct_change)
+        setattr(t, "pivot_table", pivot_table)
+        setattr(t, "pop", df_pop)
+        setattr(t, "query", df_query)
+        setattr(t, "select_dtypes", select_dtypes)
+        setattr(t, "shift", shift)
+        setattr(t, "stack", stack)
+        setattr(t, "transform", df_transform)
+        setattr(t, "transpose", transpose)
+        setattr(t, "tshift", tshift)
+
+    for t in SERIES_TYPE:
+        setattr(t, "apply", series_apply)
+        setattr(t, "astype", astype)
+        setattr(t, "case_when", case_when)
+        setattr(t, "check_monotonic", check_monotonic)
+        setattr(t, "describe", describe)
+        setattr(t, "diff", series_diff)
+        setattr(t, "drop", series_drop)
+        setattr(t, "drop_duplicates", series_drop_duplicates)
+        setattr(t, "duplicated", series_duplicated)
+        setattr(t, "explode", series_explode)
+        setattr(t, "is_monotonic", property(fget=is_monotonic))
+        setattr(t, "is_monotonic_decreasing", property(fget=is_monotonic_decreasing))
+        setattr(t, "is_monotonic_increasing", property(fget=is_monotonic_increasing))
+        setattr(t, "isin", series_isin)
+        setattr(t, "map", series_map)
+        setattr(t, "memory_usage", series_memory_usage)
+        setattr(t, "pct_change", pct_change)
+        setattr(t, "shift", shift)
+        setattr(t, "transform", series_transform)
+        setattr(t, "tshift", tshift)
+        setattr(t, "value_counts", value_counts)
+
+    for t in INDEX_TYPE:
+        setattr(t, "astype", index_astype)
+        setattr(t, "check_monotonic", check_monotonic)
+        setattr(t, "drop", index_drop)
+        setattr(t, "drop_duplicates", index_drop_duplicates)
+        setattr(t, "duplicated", index_duplicated)
+        setattr(t, "is_monotonic", property(fget=is_monotonic))
+        setattr(t, "is_monotonic_increasing", property(fget=is_monotonic_increasing))
+        setattr(t, "is_monotonic_decreasing", property(fget=is_monotonic_decreasing))
+        setattr(t, "map", index_map)
+        setattr(t, "memory_usage", index_memory_usage)
+        setattr(t, "value_counts", value_counts)
+
+    for method in _string_method_to_handlers:
+        if not hasattr(StringAccessor, method):
+            StringAccessor._register(method)
+
+    for method in _datetime_method_to_handlers:
+        if not hasattr(DatetimeAccessor, method):
+            DatetimeAccessor._register(method)
+
+    for series in SERIES_TYPE:
+        series.str = CachedAccessor("str", StringAccessor)
+        series.dt = CachedAccessor("dt", DatetimeAccessor)
+
+
+_install()
+del _install

maxframe/dataframe/misc/_duplicate.py

@@ -0,0 +1,46 @@
+# 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.
+
+import pandas as pd
+from pandas.api.types import is_list_like
+
+from ...core.operator import MapReduceOperator
+from ...serialization.serializables import AnyField, KeyField, StringField
+from ..operators import DataFrameOperatorMixin
+
+
+class DuplicateOperand(MapReduceOperator, DataFrameOperatorMixin):
+    input = KeyField("input")
+    subset = AnyField("subset", default=None)
+    keep = AnyField("keep", default="first")
+    method = StringField("method", default=None)
+
+    def _set_inputs(self, inputs):
+        super()._set_inputs(inputs)
+        self.input = self._inputs[0]
+
+
+def validate_subset(df, subset):
+    if subset is None:
+        return subset
+    if not is_list_like(subset):
+        subset = [subset]
+    else:
+        subset = list(subset)
+
+    for s in subset:
+        if s not in df.dtypes:
+            raise KeyError(pd.Index([s]))
+
+    return subset

maxframe/dataframe/misc/accessor.py

@@ -0,0 +1,276 @@
+# 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 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 .datetimes import SeriesDatetimeMethod, _datetime_method_to_handlers
+from .string_ import SeriesStringMethod, _string_method_to_handlers
+
+
+class StringAccessor:
+    """
+    Vectorized string functions for Series and Index.
+    NAs stay NA unless handled otherwise by a particular method.
+    Patterned after Python's string methods, with some inspiration from
+    R's stringr package.
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series(["A_Str_Series"])
+    >>> s.execute()
+    0    A_Str_Series
+    dtype: object
+    >>> s.str.split("_").execute()
+    0    [A, Str, Series]
+    dtype: object
+    >>> s.str.replace("_", "").execute()
+    0    AStrSeries
+    dtype: object
+    """
+
+    def __init__(self, series):
+        self._series = series
+
+    @classmethod
+    def _gen_func(cls, method):
+        @wraps(getattr(pd.Series.str, method))
+        def _inner(self, *args, **kwargs):
+            op = SeriesStringMethod(
+                method=method, method_args=args, method_kwargs=kwargs
+            )
+            return op(self._series)
+
+        _inner.__doc__ = adapt_docstring(getattr(pd.Series.str, method).__doc__)
+        return _inner
+
+    def __getitem__(self, item):
+        return self._gen_func("__getitem__")(self, item)
+
+    def __dir__(self) -> Iterable[str]:
+        s = set(super().__dir__())
+        s.update(_string_method_to_handlers.keys())
+        return list(s)
+
+    @classmethod
+    def _register(cls, method):
+        setattr(cls, method, cls._gen_func(method))
+
+    def split(self, pat=None, n=-1, expand=False):
+        r"""
+        Split strings around given separator/delimiter.
+
+        Splits the string in the Series/Index from the beginning,
+        at the specified delimiter string. Equivalent to :meth:`str.split`.
+
+        Parameters
+        ----------
+        pat : str, optional
+            String or regular expression to split on.
+            If not specified, split on whitespace.
+        n : int, default -1 (all)
+            Limit number of splits in output.
+            ``None``, 0 and -1 will be interpreted as return all splits.
+        expand : bool, default False
+            Expand the splitted strings into separate columns.
+
+            * If ``True``, return DataFrame/MultiIndex expanding dimensionality.
+            * If ``False``, return Series/Index, containing lists of strings.
+
+        Returns
+        -------
+        Series, Index, DataFrame or MultiIndex
+            Type matches caller unless ``expand=True`` (see Notes).
+
+        See Also
+        --------
+        Series.str.split : Split strings around given separator/delimiter.
+        Series.str.rsplit : Splits string around given separator/delimiter,
+            starting from the right.
+        Series.str.join : Join lists contained as elements in the Series/Index
+            with passed delimiter.
+        str.split : Standard library version for split.
+        str.rsplit : Standard library version for rsplit.
+
+        Notes
+        -----
+        The handling of the `n` keyword depends on the number of found splits:
+
+        - If found splits > `n`,  make first `n` splits only
+        - If found splits <= `n`, make all splits
+        - If for a certain row the number of found splits < `n`,
+          append `None` for padding up to `n` if ``expand=True``
+
+        If using ``expand=True``, Series and Index callers return DataFrame and
+        MultiIndex objects, respectively.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> import maxframe.dataframe as md
+        >>> s = md.Series(["this is a regular sentence",
+        >>>                "https://docs.python.org/3/tutorial/index.html",
+        >>>                np.nan])
+        >>> s.execute()
+        0                       this is a regular sentence
+        1    https://docs.python.org/3/tutorial/index.html
+        2                                              NaN
+        dtype: object
+
+        In the default setting, the string is split by whitespace.
+
+        >>> s.str.split().execute()
+        0                   [this, is, a, regular, sentence]
+        1    [https://docs.python.org/3/tutorial/index.html]
+        2                                                NaN
+        dtype: object
+
+        Without the `n` parameter, the outputs of `rsplit` and `split`
+        are identical.
+
+        >>> s.str.rsplit().execute()
+        0                   [this, is, a, regular, sentence]
+        1    [https://docs.python.org/3/tutorial/index.html]
+        2                                                NaN
+        dtype: object
+
+        The `n` parameter can be used to limit the number of splits on the
+        delimiter. The outputs of `split` and `rsplit` are different.
+
+        >>> s.str.split(n=2).execute()
+        0                     [this, is, a regular sentence]
+        1    [https://docs.python.org/3/tutorial/index.html]
+        2                                                NaN
+        dtype: object
+
+        >>> s.str.rsplit(n=2).execute()
+        0                     [this is a, regular, sentence]
+        1    [https://docs.python.org/3/tutorial/index.html]
+        2                                                NaN
+        dtype: object
+
+        The `pat` parameter can be used to split by other characters.
+
+        >>> s.str.split(pat = "/").execute()
+        0                         [this is a regular sentence]
+        1    [https:, , docs.python.org, 3, tutorial, index...
+        2                                                  NaN
+        dtype: object
+
+        When using ``expand=True``, the split elements will expand out into
+        separate columns. If NaN is present, it is propagated throughout
+        the columns during the split.
+
+        >>> s.str.split(expand=True).execute()
+                                                       0     1     2        3
+        0                                           this    is     a  regular
+        1  https://docs.python.org/3/tutorial/index.html  None  None     None
+        2                                            NaN   NaN   NaN      NaN \
+                     4
+        0     sentence
+        1         None
+        2          NaN
+
+        For slightly more complex use cases like splitting the html document name
+        from a url, a combination of parameter settings can be used.
+
+        >>> s.str.rsplit("/", n=1, expand=True).execute()
+                                            0           1
+        0          this is a regular sentence        None
+        1  https://docs.python.org/3/tutorial  index.html
+        2                                 NaN         NaN
+
+        Remember to escape special characters when explicitly using regular
+        expressions.
+
+        >>> s = pd.Series(["1+1=2"])
+        >>> s.str.split(r"\+|=", expand=True).execute()
+             0    1    2
+        0    1    1    2
+        """
+        return self._gen_func("split")(self, pat=pat, n=n, expand=expand)
+
+    def rsplit(self, pat=None, n=-1, expand=False):
+        return self._gen_func("rsplit")(self, pat=pat, n=n, expand=expand)
+
+    def cat(self, others=None, sep=None, na_rep=None, join="left"):
+        return self._gen_func("cat")(
+            self, others=others, sep=sep, na_rep=na_rep, join=join
+        )
+
+    rsplit.__doc__ = adapt_docstring(pd.Series.str.rsplit.__doc__)
+    cat.__doc__ = adapt_docstring(pd.Series.str.cat.__doc__)
+
+
+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)
+
+
+class CachedAccessor:
+    def __init__(self, name: str, accessor) -> None:
+        self._name = name
+        self._accessor = accessor
+
+    def __get__(self, obj, cls):
+        if obj is None:
+            # we're accessing the attribute of the class, i.e., Dataset.geo
+            return self._accessor
+        if self._name not in obj._accessors:
+            obj._accessors[self._name] = self._accessor(obj)
+        return obj._accessors[self._name]