maxframe 0.1.0b5__cp311-cp311-win32.whl → 1.0.0__cp311-cp311-win32.whl

maxframe/dataframe/extensions/flatjson.py

@@ -0,0 +1,131 @@
+# 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 List
+
+from ... import opcodes
+from ...core import OutputType
+from ...serialization.serializables import ListField
+from ...serialization.serializables.field_type import FieldTypes
+from ..core import DataFrame
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import make_dtypes, parse_index
+
+
+class SeriesFlatJSONOperator(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.FLATJSON
+
+    query_paths = ListField("query_paths", field_type=FieldTypes.string, default=None)
+
+    def __call__(self, series, dtypes):
+        if self._output_types[0] == OutputType.series:
+            name, dtype = dtypes
+            return self.new_series(
+                [series],
+                shape=series.shape,
+                index_value=series.index_value,
+                name=name,
+                dtype=dtype,
+            )
+        return self.new_dataframe(
+            [series],
+            shape=(series.shape[0], len(dtypes)),
+            index_value=series.index_value,
+            columns_value=parse_index(dtypes.index, store_data=True),
+            dtypes=make_dtypes(dtypes),
+        )
+
+
+def series_flatjson(
+    series,
+    query_paths: List[str],
+    dtypes=None,
+    dtype=None,
+    name: str = None,
+) -> DataFrame:
+    """
+    Flat JSON object in the series to a dataframe according to JSON query.
+
+    Parameters
+    ----------
+    series : Series
+        The series of json strings.
+
+    query_paths: List[str] or str
+        The JSON query paths for each generated column. The path format should follow
+        [RFC9535](https://datatracker.ietf.org/doc/rfc9535/).
+
+    dtypes : Series, default None
+        Specify dtypes of returned DataFrame. Can't work with dtype.
+
+    dtype : numpy.dtype, default None
+        Specify dtype of returned Series. Can't work with dtypes.
+
+    name : str, default None
+        Specify name of the returned Series.
+
+    Returns
+    -------
+    DataFrame or Series
+        Result of DataFrame when dtypes specified, else Series.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> import pandas as pd
+    >>> s = md.Series(
+    ...     [
+    ...         '{"age": 24, "gender": "male", "graduated": false}',
+    ...         '{"age": 25, "gender": "female", "graduated": true}',
+    ...     ]
+    ... )
+    >>> s.execute()
+    0    {"age": 24, "gender": "male", "graduated": false}
+    1    {"age": 25, "gender": "female", "graduated": true}
+    dtype: object
+
+    >>> df = s.mf.flatjson(
+    ...    ["$.age", "$.gender", "$.graduated"],
+    ...    dtypes=pd.Series(["int32", "object", "bool"], index=["age", "gender", "graduated"]),
+    ... )
+    >>> df.execute()
+        age  gender  graduated
+    0   24    male       True
+    1   25  female       True
+
+    >>> s2 = s.mf.flatjson("$.age", name="age", dtype="int32")
+    >>> s2.execute()
+    0    24
+    1    25
+    Name: age, dtype: int32
+    """
+    if isinstance(query_paths, str):
+        query_paths = [query_paths]
+    if dtypes is not None and dtype is not None:
+        raise ValueError("Both dtypes and dtype cannot be specified at the same time.")
+    if dtype is not None:
+        if len(query_paths) != 1:
+            raise ValueError("query_paths should have only one path if dtype is set")
+        output_type = OutputType.series
+    elif dtypes is not None:
+        if len(dtypes) != len(query_paths):
+            raise ValueError("query_paths and dtypes should have same length")
+        output_type = OutputType.dataframe
+    else:
+        raise ValueError("dtypes or dtype should be specified")
+
+    dtypes = (name, dtype) if dtype is not None else dtypes
+    return SeriesFlatJSONOperator(query_paths=query_paths, _output_types=[output_type])(
+        series, dtypes
+    )

maxframe/dataframe/extensions/flatmap.py

@@ -0,0 +1,317 @@
+# 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 Callable
+
+import numpy as np
+import pandas as pd
+
+from ... import opcodes
+from ...core import OutputType
+from ...serialization.serializables import (
+    BoolField,
+    DictField,
+    FunctionField,
+    TupleField,
+)
+from ..core import DataFrame
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import gen_unknown_index_value, make_dtypes, parse_index
+
+
+class DataFrameFlatMapOperator(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.FLATMAP
+
+    func = FunctionField("func")
+    raw = BoolField("raw", default=False)
+    args = TupleField("args", default=())
+    kwargs = DictField("kwargs", default={})
+
+    def __init__(self, output_types=None, **kw):
+        super().__init__(_output_types=output_types, **kw)
+
+    def _call_dataframe(self, df: DataFrame, dtypes: pd.Series):
+        dtypes = make_dtypes(dtypes)
+        index_value = gen_unknown_index_value(
+            df.index_value,
+            (df.key, df.index_value.key, self.func),
+            normalize_range_index=True,
+        )
+        return self.new_dataframe(
+            [df],
+            shape=(np.nan, len(dtypes)),
+            index_value=index_value,
+            columns_value=parse_index(dtypes.index, store_data=True),
+            dtypes=dtypes,
+        )
+
+    def _call_series_or_index(self, series, dtypes=None):
+        index_value = gen_unknown_index_value(
+            series.index_value,
+            (series.key, series.index_value.key, self.func),
+            normalize_range_index=True,
+        )
+
+        if self.output_types[0] == OutputType.series:
+            name, dtype = dtypes
+            return self.new_series(
+                [series],
+                dtype=dtype,
+                shape=(np.nan,),
+                index_value=index_value,
+                name=name,
+            )
+
+        dtypes = make_dtypes(dtypes)
+        columns_value = parse_index(dtypes.index, store_data=True)
+        return self.new_dataframe(
+            [series],
+            shape=(np.nan, len(dtypes)),
+            index_value=index_value,
+            columns_value=columns_value,
+            dtypes=dtypes,
+        )
+
+    def __call__(
+        self,
+        df_or_series,
+        dtypes=None,
+        output_type=None,
+    ):
+        if df_or_series.op.output_types[0] == OutputType.dataframe:
+            return self._call_dataframe(df_or_series, dtypes=dtypes)
+        else:
+            return self._call_series_or_index(df_or_series, dtypes=dtypes)
+
+
+def df_flatmap(dataframe, func: Callable, dtypes=None, raw=False, args=(), **kwargs):
+    """
+    Apply the given function to each row and then flatten results. Use this method if your transformation returns
+    multiple rows for each input row.
+
+    This function applies a transformation to each row of the DataFrame, where the transformation can return zero
+    or multiple values, effectively flattening Python generators, list-like collections, and DataFrames.
+
+    Parameters
+    ----------
+    dataframe : DataFrame
+        The DataFrame to which the function will be applied.
+
+    func : Callable
+        Function to apply to each row of the DataFrame. It should accept a Series (or an array if `raw=True`)
+        representing a row and return a list or iterable of values.
+
+    dtypes : Series, dict or list
+        Specify dtypes of returned DataFrame.
+
+    raw : bool, default False
+        Determines if the row is passed as a Series or as a numpy array:
+
+        * ``False`` : passes each row as a Series to the function.
+        * ``True`` : the passed function will receive numpy array objects instead.
+
+    args : tuple
+        Positional arguments to pass to `func`.
+
+    **kwargs
+        Additional keyword arguments to pass as keywords arguments to `func`.
+
+    Returns
+    -------
+    DataFrame
+        Return DataFrame with specified `dtypes`.
+
+    Notes
+    -----
+    The `func` must return an iterable of values for each input row. The index of the resulting DataFrame will be
+     repeated based on the number of output rows generated by `func`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
+    >>> df.execute()
+       A  B
+    0  1  4
+    1  2  5
+    2  3  6
+
+    Define a function that takes a number and returns a list of two numbers:
+
+    >>> def generate_values_array(row):
+    ...     return [row['A'] * 2, row['B'] * 3]
+
+    Define a function that takes a row and return two rows and two columns:
+
+    >>> def generate_values_in_generator(row):
+    ...     yield [row[0] * 2, row[1] * 4]
+    ...     yield [row[0] * 3, row[1] * 5]
+
+    Which equals to the following function return a dataframe:
+
+    >>> def generate_values_in_dataframe(row):
+    ...     return pd.DataFrame([[row[0] * 2, row[1] * 4], [row[0] * 3, row[1] * 5]])
+
+    Specify `dtypes` with a function which returns a DataFrame:
+
+    >>> df.mf.flatmap(generate_values_array, dtypes=pd.Series({'A': 'int'})).execute()
+            A
+        0   2
+        0  12
+        1   4
+        1  15
+        2   6
+        2  18
+
+    Specify raw=True to pass input row as array:
+
+    >>> df.mf.flatmap(generate_values_in_generator, dtypes={"A": "int", "B": "int"}, raw=True).execute()
+           A   B
+        0  2  16
+        0  3  20
+        1  4  20
+        1  6  25
+        2  6  24
+        2  9  30
+    """
+    if dtypes is None or len(dtypes) == 0:
+        raise TypeError(
+            "Cannot determine {dtypes} by calculating with enumerate data, "
+            "please specify it as arguments"
+        )
+
+    if not isinstance(func, Callable):
+        raise TypeError("function must be a callable object")
+
+    output_types = [OutputType.dataframe]
+    op = DataFrameFlatMapOperator(
+        func=func, raw=raw, output_types=output_types, args=args, kwargs=kwargs
+    )
+    return op(
+        dataframe,
+        dtypes=dtypes,
+    )
+
+
+def series_flatmap(
+    series, func: Callable, dtypes=None, dtype=None, name=None, args=(), **kwargs
+):
+    """
+    Apply the given function to each row and then flatten results. Use this method if your transformation returns
+    multiple rows for each input row.
+
+    This function applies a transformation to each element of the Series, where the transformation can return zero
+     or multiple values, effectively flattening Python generator, list-liked collections and DataFrame.
+
+    Parameters
+    ----------
+    series : Series
+        The series to which the function will be applied.
+
+    func : Callable
+        Function to apply to each element of the Series. It should accept a scalar value
+        (or an array if `raw=True`) and return a list or iterable of values.
+
+    dtypes : Series, default None
+        Specify dtypes of returned DataFrame. Can't work with dtype.
+
+    dtype : numpy.dtype, default None
+        Specify dtype of returned Series. Can't work with dtypes.
+
+    name : str, default None
+        Specify name of the returned Series.
+
+    args : tuple
+        Positional arguments to pass to `func`.
+
+    **kwargs
+        Additional keyword arguments to pass as keywords arguments to `func`.
+
+    Returns
+    -------
+    DataFrame or Series
+        Result of DataFrame when dtypes specified, else Series.
+
+    Notes
+    -----
+    The `func` must return an iterable of values for each input element. If `dtypes` is specified,
+    `flatmap` will return a DataFrame, if `dtype` and `name` is specified, a Series will be returned. The index of
+     the resulting DataFrame/Series will be repeated based on the number of output rows generated by `func`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
+    >>> df.execute()
+       A  B
+    0  1  4
+    1  2  5
+    2  3  6
+
+    Define a function that takes a number and returns a list of two numbers:
+
+    >>> def generate_values_array(x):
+    ...     return [x * 2, x * 3]
+
+    >>> def generate_values_in_generator(x):
+    ...     yield pd.Series([x * 2, x * 4])
+    ...     yield pd.Series([x * 3, x * 5])
+
+    Specify `dtype` with a function which returns list to return more than one elements as a Series:
+
+    >>> df['A'].mf.flatmap(generate_values_array, dtype="int", name="C").execute()
+        0    2
+        0    3
+        1    4
+        1    6
+        2    6
+        2    9
+        Name: C, dtype: int64
+
+    Specify `dtypes` to return multi columns as a DataFrame:
+
+    >>> df['A'].mf.flatmap(generate_values_in_generator, dtypes={"A": "int", "B": "int"}).execute()
+           A   B
+        0  2   4
+        0  3   5
+        1  4   8
+        1  6  10
+        2  6  12
+        2  9  15
+    """
+
+    if dtypes is not None and dtype is not None:
+        raise ValueError("Both dtypes and dtype cannot be specified at the same time.")
+
+    dtypes = (name, dtype) if dtype is not None else dtypes
+    if dtypes is None:
+        raise TypeError(
+            "Cannot determine {dtypes} or {dtype} by calculating with enumerate data, "
+            "please specify it as arguments"
+        )
+
+    if not isinstance(func, Callable):
+        raise TypeError("function must be a callable object")
+
+    output_type = OutputType.series if dtype is not None else OutputType.dataframe
+
+    op = DataFrameFlatMapOperator(
+        func=func, raw=False, output_types=[output_type], args=args, kwargs=kwargs
+    )
+    return op(
+        series,
+        dtypes=dtypes,
+    )

maxframe/dataframe/extensions/reshuffle.py

@@ -38,7 +38,7 @@ class DataFrameReshuffle(DataFrameOperator, DataFrameOperatorMixin):
         else:
             idx_value = df.index_value
             if isinstance(idx_value.value, IndexValue.RangeIndex):
-                idx_value = parse_index(pd.Int64Index([0]))
+                idx_value = parse_index(pd.RangeIndex(1))
         params = df.params
         params["index_value"] = idx_value
         self._output_types = get_output_types(df)

maxframe/dataframe/extensions/tests/test_extensions.py

@@ -11,12 +11,14 @@
 # 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 .... import dataframe as md
-from ...core import IndexValue
+from ....tests.utils import assert_mf_index_dtype
+from ... import DataFrame
+from ...core import DATAFRAME_TYPE, SERIES_TYPE, IndexValue
 from ..reshuffle import DataFrameReshuffle
 
 
@@ -31,8 +33,111 @@ def test_reshuffle():
 
     r = mdf.mf.reshuffle()
     assert isinstance(r.op, DataFrameReshuffle)
-    assert isinstance(r.index_value.value, IndexValue.Int64Index)
+    assert_mf_index_dtype(r.index_value.value, np.int64)
 
     r = mdf.mf.reshuffle(ignore_index=True)
     assert isinstance(r.op, DataFrameReshuffle)
     assert isinstance(r.index_value.value, IndexValue.RangeIndex)
+
+
+@pytest.fixture
+def df1():
+    return DataFrame({"a": [1, 2, 3], "b": [1, 2, 3], "c": [1, 2, 3]})
+
+
+@pytest.fixture
+def df2():
+    return DataFrame([[1, 2, 3], [1, 2, 3], [1, 2, 3]], columns=["a", "b", "c"])
+
+
+@pytest.fixture
+def df3():
+    return DataFrame(
+        [[1, 2, 3], [1, 2, 3], [1, 2, 3]],
+        columns=["a", "b", "c"],
+        index=pd.MultiIndex.from_arrays([[1, 2, 3], [1, 2, 3]], names=["A", "B"]),
+    )
+
+
+def test_flatmap(df1, df2, df3):
+    def f(x, keys):
+        if x["a"] in keys:
+            yield [1, 0]
+            yield [0, 1]
+
+    apply_df = df1[["a"]].mf.flatmap(
+        f,
+        dtypes={"a": "int64", "b": "int64"},
+    )
+    assert apply_df.shape == (np.nan, 2)
+    assert df1.index_value.key != apply_df.index_value.key
+    assert isinstance(df1.index_value.to_pandas(), pd.RangeIndex)
+    assert not isinstance(apply_df.index_value.to_pandas(), pd.RangeIndex)
+    apply_df = df2[["a"]].mf.flatmap(
+        f,
+        dtypes=pd.Series(["int64", "int64"]),
+    )
+    assert apply_df.shape == (np.nan, 2)
+    assert df2.index_value.key != apply_df.index_value.key
+    with pytest.raises(TypeError):
+        apply_s = df3["a"].mf.flatmap(
+            f,
+        )
+    apply_s = df3["a"].mf.flatmap(
+        f,
+        dtype="int64",
+    )
+    assert apply_s.shape == (np.nan,)
+    assert df3.index_value.key != apply_s.index_value.key
+    assert df3.key != apply_s.index_value.key
+    apply_s = df3["a"].mf.flatmap(
+        f,
+        output_type="dataframe",
+        dtypes=["int64", "int64"],
+    )
+    assert apply_s.shape == (np.nan, 2)
+    assert df3.index_value.key != apply_s.index_value.key
+    assert df3.key != apply_s.index_value.key
+
+
+def test_flatjson():
+    s1 = md.Series(["{{'a': 1, 'b': false}}"], index=[1])
+    df1 = s1.mf.flatjson(
+        ["$.a", "$.b"], dtypes=pd.Series(["int32", "bool"], index=["a", "b"])
+    )
+    assert df1.shape == (1, 2)
+    assert df1.index_value.key == s1.index_value.key
+    assert isinstance(df1, DATAFRAME_TYPE)
+    assert list(df1.dtypes) == [np.dtype("int32"), np.dtype("bool")]
+    assert list(df1.dtypes.index) == ["a", "b"]
+
+    df2 = s1.mf.flatjson(["$.a"], dtypes=pd.Series(["int32"], index=["a"]))
+    assert df2.shape == (1, 1)
+    assert df2.index_value.key == s1.index_value.key
+    assert isinstance(df2, DATAFRAME_TYPE)
+    assert list(df2.dtypes) == [np.dtype("int32")]
+    assert list(df2.dtypes.index) == ["a"]
+
+    s2 = s1.mf.flatjson("$.a", dtype="int32", name="a")
+    assert s2.shape == (1,)
+    assert s2.index_value.key == s1.index_value.key
+    assert isinstance(s2, SERIES_TYPE)
+    assert s2.dtype == np.dtype("int32")
+    assert s2.name == "a"
+
+    with pytest.raises(ValueError):
+        s1.mf.flatjson([], dtypes=pd.Series(["int32", "bool"], index=["a", "b"]))
+    with pytest.raises(ValueError):
+        s1.mf.flatjson(["$.a"], dtypes=pd.Series(["int32", "bool"], index=["a", "b"]))
+    with pytest.raises(ValueError):
+        s1.mf.flatjson(["$.a"], dtypes=pd.Series(["int32", "bool"], index=["a", "b"]))
+    with pytest.raises(ValueError):
+        s1.mf.flatjson(["$.a", "$.b"], dtypes=pd.Series(["bool"], index=["b"]))
+    with pytest.raises(ValueError):
+        s1.mf.flatjson(
+            ["$.a"],
+            dtype="int32",
+            dtypes=pd.Series(["int32"], index=["a"]),
+        )
+    with pytest.raises(ValueError):
+        s1.mf.flatjson(["$.a"])

maxframe/dataframe/groupby/core.py

@@ -28,7 +28,7 @@ from ..utils import build_df, build_series, parse_index
 
 cudf = lazy_import("cudf")
 
-_GROUP_KEYS_NO_DEFAULT = pd_release_version >= (1, 5, 0)
+_GROUP_KEYS_NO_DEFAULT = pd_release_version[:2] == (1, 5)
 _default_group_keys = no_default if _GROUP_KEYS_NO_DEFAULT else True
 
 

maxframe/dataframe/groupby/cum.py

@@ -59,7 +59,6 @@ class GroupByCumReductionOperator(DataFrameOperatorMixin, DataFrameOperator):
         out_dtypes = self._calc_out_dtypes(groupby)
 
         kw = in_df.params.copy()
-        kw["index_value"] = parse_index(pd.RangeIndex(-1), groupby.key)
         if self.output_types[0] == OutputType.dataframe:
             kw.update(
                 dict(

maxframe/dataframe/groupby/fill.py

@@ -35,12 +35,15 @@ class GroupByFillOperator(DataFrameOperator, DataFrameOperatorMixin):
         func_name = getattr(self, "_func_name")
 
         if func_name == "fillna":
+            kw = {}
+            if self.axis is not None:
+                kw["axis"] = self.axis
             result_df = mock_groupby.fillna(
                 value=self.value,
                 method=self.method,
-                axis=self.axis,
                 limit=self.limit,
                 downcast=self.downcast,
+                **kw,
             )
         else:
             result_df = getattr(mock_groupby, func_name)(limit=self.limit)

maxframe/dataframe/groupby/getitem.py

@@ -88,5 +88,11 @@ def df_groupby_getitem(df_groupby, item):
     if df_groupby.selection:
         raise IndexError(f"Column(s) {df_groupby.selection!r} already selected")
 
+    if (
+        isinstance(item, tuple)
+        and item not in df_groupby.dtypes
+        and item not in df_groupby.index.names
+    ):
+        item = list(item)
     op = GroupByIndex(selection=item, output_types=output_types)
     return op(df_groupby)

maxframe/dataframe/groupby/tests/test_groupby.py

@@ -230,7 +230,7 @@ def test_groupby_transform():
     assert r.op._op_type_ == opcodes.TRANSFORM
     assert r.op.output_types[0] == OutputType.dataframe
 
-    r = mdf.groupby("b").transform(["cummax", "cumcount"], _call_agg=True)
+    r = mdf[list("abde")].groupby("b").transform(["cummax", "cumcount"], _call_agg=True)
     assert r.shape == (np.nan, 6)
     assert r.op._op_type_ == opcodes.TRANSFORM
     assert r.op.output_types[0] == OutputType.dataframe
@@ -282,14 +282,17 @@ def test_groupby_cum():
         r = getattr(mdf.groupby("b"), fun)()
         assert r.op.output_types[0] == OutputType.dataframe
         assert r.shape == (len(df1), 2)
+        assert r.index_value.key == mdf.index_value.key
 
         r = getattr(mdf.groupby("b"), fun)(axis=1)
         assert r.op.output_types[0] == OutputType.dataframe
         assert r.shape == (len(df1), 3)
+        assert r.index_value.key == mdf.index_value.key
 
     r = mdf.groupby("b").cumcount()
     assert r.op.output_types[0] == OutputType.series
     assert r.shape == (len(df1),)
+    assert r.index_value.key == mdf.index_value.key
 
     series1 = pd.Series([2, 2, 5, 7, 3, 7, 8, 8, 5, 6])
     ms1 = md.Series(series1, chunk_size=3)
@@ -298,6 +301,7 @@ def test_groupby_cum():
         r = getattr(ms1.groupby(lambda x: x % 2), fun)()
         assert r.op.output_types[0] == OutputType.series
         assert r.shape == (len(series1),)
+        assert r.index_value.key == ms1.index_value.key
 
 
 def test_groupby_fill():

maxframe/dataframe/groupby/transform.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import logging
+
 import numpy as np
 import pandas as pd
 
@@ -22,6 +24,8 @@ from ...utils import quiet_stdio
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
 from ..utils import parse_index
 
+logger = logging.getLogger(__name__)
+
 
 class GroupByTransform(DataFrameOperator, DataFrameOperatorMixin):
     _op_type_ = opcodes.TRANSFORM
@@ -65,7 +69,7 @@ class GroupByTransform(DataFrameOperator, DataFrameOperatorMixin):
                 output_types = [OutputType.series]
                 new_dtypes = new_dtypes or (infer_df.name, infer_df.dtype)
         except:  # noqa: E722  # nosec
-            pass
+            logger.info("Exception raised while inferring df_func", exc_info=True)
 
         self.output_types = output_types if not self.output_types else self.output_types
         dtypes = new_dtypes if dtypes is None else dtypes