maxframe 2.0.0b2__cp39-cp39-win_amd64.whl → 2.3.0rc1__cp39-cp39-win_amd64.whl

maxframe/__init__.py

@@ -14,6 +14,7 @@
 
 from . import dataframe, learn, remote, tensor
 from .config import options
+from .lib.dtypes_extension import ExternalBlobDtype
 from .session import execute, fetch, new_session, stop_server
 
 

maxframe/_utils.pyx

@@ -299,6 +299,18 @@ cdef inline _extract_range_index_attr(object range_index, str attr):
         return getattr(range_index, '_' + attr)
 
 
+cdef list tokenize_type(ob):
+    try:
+        pickle.dumps(ob)
+        return [ob]
+    except:
+        pass
+    try:
+        return [cloudpickle.dumps(ob)]
+    except:
+        raise TypeError(f'Cannot generate token for {ob}, type: {type(ob)}') from None
+
+
 cdef list tokenize_pandas_index(ob):
     cdef long long start
     cdef long long stop
@@ -411,7 +423,7 @@ def tokenize_cudf(ob):
 cdef Tokenizer tokenize_handler = Tokenizer()
 
 cdef set _primitive_types = {
-    int, float, str, unicode, bytes, complex, type(None), type, slice, date, datetime, timedelta
+    int, float, str, unicode, bytes, complex, type(None), slice, date, datetime, timedelta
 }
 for t in _primitive_types:
     tokenize_handler.register(t, lambda ob: ob)
@@ -422,6 +434,7 @@ for t in (np.dtype, np.generic):
 for t in (list, tuple, dict, set):
     tokenize_handler.register(t, iterative_tokenize)
 
+tokenize_handler.register(type, tokenize_type)
 tokenize_handler.register(np.ndarray, tokenize_numpy)
 tokenize_handler.register(np.random.RandomState, lambda ob: iterative_tokenize(ob.get_state()))
 tokenize_handler.register(memoryview, lambda ob: mmh3_hash_from_buffer(ob))

maxframe/codegen/core.py

@@ -23,7 +23,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Type, Union
 from odps.types import OdpsSchema
 from odps.utils import camel_to_underline
 
-from ..core import OperatorType, Tileable, TileableGraph
+from ..core import OperatorType, Tileable, TileableGraph, enter_mode
 from ..core.operator import Fetch, Operator
 from ..extension import iter_extensions
 from ..io.odpsio import build_dataframe_table_meta
@@ -148,31 +148,31 @@ class UserCodeMixin:
     def generate_pickled_codes(
         cls,
         code_to_pickle: Any,
-        unpicked_data_var_name: Union[str, None] = "pickled_data",
+        main_entry_var_name: Union[str, None] = "udf_main_entry",
     ) -> str:
         """
-        Generate pickled codes. The final pickled variable is called 'pickled_data'.
+        Generate pickled codes. The final pickled variable is called 'udf_main_entry'.
 
         Parameters
         ----------
         code_to_pickle: Any
             The code to be pickled.
-        unpicked_data_var_name: str
+        main_entry_var_name: str
             The variables in code used to hold the loads object from the cloudpickle
 
         Returns
         -------
         str :
             The code snippets of pickling, the final variable is called
-            'pickled_data' by default.
+            'udf_main_entry' by default.
         """
         pickled, buffers = cls.dump_pickled_data(code_to_pickle)
         pickle_loads_expr = (
             f"cloudpickle.loads({cls.obj_to_python_expr(pickled)}, "
             f"buffers={cls.obj_to_python_expr(buffers)})"
         )
-        if unpicked_data_var_name:
-            return f"{unpicked_data_var_name} = {pickle_loads_expr}"
+        if main_entry_var_name:
+            return f"{main_entry_var_name} = {pickle_loads_expr}"
 
         return pickle_loads_expr
 
@@ -465,6 +465,7 @@ class DAGCodeGenerator(metaclass=abc.ABCMeta):
     def _generate_delete_code(self, var_name: str) -> List[str]:
         return []
 
+    @enter_mode(build=True)
     def generate_code(self, dag: TileableGraph) -> List[str]:
         """
         Generate the code of the input dag.
@@ -494,7 +495,7 @@ class DAGCodeGenerator(metaclass=abc.ABCMeta):
             code_lines.extend(adapter.generate_pre_op_code(op, self._context))
             if self._generate_comments_enabled:
                 code_lines.extend(adapter.generate_comment(op, self._context))
-            code_lines.extend(adapter.generate_code(op, self._context))
+            code_lines.extend(adapter.generate_code(op, self._context) or [])
             code_lines.extend(adapter.generate_post_op_code(op, self._context))
             code_lines.append("")  # Append an empty line to separate operators
 

maxframe/codegen/spe/core.py

@@ -299,7 +299,7 @@ class SPECodeGenerator(DAGCodeGenerator):
         udf_codes = list()
         for func in self.get_udfs():
             udf_codes.extend(func.encoded_content)
-            udf_codes.append(f"{func.name} = pickled_data")
+            udf_codes.append(f"{func.name} = udf_main_entry")
         return udf_codes
 
 

maxframe/codegen/spe/dataframe/__init__.py

@@ -24,6 +24,7 @@ from . import (
     misc,
     missing,
     reduction,
+    reshape,
     sort,
     statistics,
     tseries,

maxframe/codegen/spe/dataframe/accessors/base.py

@@ -51,3 +51,21 @@ class SeriesStringMethodAdapter(SPEOperatorAdapter):
         )
         args = ", ".join(args_list)
         return [f"{res_var_name} = {method_str}({args})"]
+
+
+class SeriesTemplateMethodAdapter(SPEOperatorAdapter):
+    _templates = None
+
+    def generate_code(self, op, context: SPECodeContext) -> List[str]:
+        kw = {
+            "input_var": context.get_input_tileable_variable(op.inputs[0]),
+            "output_var": context.get_output_tileable_variable(op.outputs[0]),
+            "output_name_var": self.translate_var(context, op.outputs[0].name),
+            "output_dtype_var": context.register_operator_constants(
+                op.outputs[0].dtype
+            ),
+        }
+        kw.update(
+            {k: self.translate_var(context, v) for k, v in op.method_kwargs.items()}
+        )
+        return [self._templates.get(op.method).format(**kw)]

maxframe/codegen/spe/dataframe/accessors/dict_.py

@@ -12,30 +12,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import List
-
-from .....dataframe.accessors.dict_.contains import SeriesDictContainsOperator
-from .....dataframe.accessors.dict_.getitem import SeriesDictGetItemOperator
-from .....dataframe.accessors.dict_.length import SeriesDictLengthOperator
-from .....dataframe.accessors.dict_.remove import SeriesDictRemoveOperator
-from .....dataframe.accessors.dict_.setitem import SeriesDictSetItemOperator
-from ...core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+from .....dataframe.accessors.dict_.core import SeriesDictMethod
+from ...core import register_op_adapter
+from .base import SeriesTemplateMethodAdapter
 
 _get_template = """
 def _inner_get(data):
     found = False
     for tup in data:
-        if tup[0] == {key_var}:
+        if tup[0] == {query_key}:
             found = True
             return tup[1]
     if not found:
-        if {ignore_key_error_var}:
-            return {default_value_var}
+        if {ignore_key_error}:
+            return {default_value}
         else:
-            raise KeyError({key_var})
+            raise KeyError({query_key})
 
 {output_var} = {input_var}.map(_inner_get, na_action="ignore").astype({output_dtype_var})
-{output_var}.name = {key_var}
+{output_var}.name = {query_key}
 """
 
 _set_template = """
@@ -43,19 +38,19 @@ def _inner_set(row):
     found = False
     value = list()
     for tup in row:
-        if tup[0] == {key_var}:
-            value.append((tup[0], {value_var}))
+        if tup[0] == {query_key}:
+            value.append((tup[0], {value}))
             found = True
         else:
             value.append(tup)
     if not found:
-        value.append(({key_var}, {value_var}))
+        value.append(({query_key}, {value}))
     return value
 
 {output_var} = {input_var}.map(_inner_set, na_action="ignore").astype({output_dtype_var})
 """
 
-_length_template = """
+_len_template = """
 {output_var} = {input_var}.map(len, na_action="ignore").astype({output_dtype_var})
 {output_var}.name = None
 """
@@ -66,129 +61,29 @@ def _inner_remove(value):
     row = list()
     found = False
     for tup in value:
-        if tup[0] == {key_var}:
+        if tup[0] == {query_key}:
             found = True
         else:
             row.append(tup)
-    if not found and not {ignore_key_error_var}:
-        raise KeyError({key_var})
+    if not found and not {ignore_key_error}:
+        raise KeyError({query_key})
     return row
 
 {output_var} = {input_var}.map(_inner_remove, na_action="ignore").astype({output_dtype_var})
 """
 
 _contains_template = """
-{output_var} = {input_var}.map(lambda x: any({key_var} in tup[0] for tup in x), na_action="ignore").astype({output_dtype_var})
+{output_var} = {input_var}.map(lambda x: any({query_key} in tup[0] for tup in x), na_action="ignore").astype({output_dtype_var})
 {output_var}.name = None
 """
 
 
-@register_op_adapter(SeriesDictGetItemOperator)
-class SeriesDictGetItemOperatorAdapter(SPEOperatorAdapter):
-    def generate_code(
-        self, op: SeriesDictGetItemOperator, context: SPECodeContext
-    ) -> List[str]:
-        input_var = context.get_input_tileable_variable(op.inputs[0])
-        output_var = context.get_output_tileable_variable(op.outputs[0])
-        key_var = self.translate_var(context, op.query_key)
-        output_name_var = self.translate_var(context, op.outputs[0].name)
-        default_value_var = self.translate_var(context, op.default_value)
-        ignore_key_error_var = self.translate_var(context, op.ignore_key_error)
-        output_dtype_var = context.register_operator_constants(op.outputs[0].dtype)
-        return [
-            _get_template.format(
-                input_var=input_var,
-                output_var=output_var,
-                key_var=key_var,
-                default_value_var=default_value_var,
-                ignore_key_error_var=ignore_key_error_var,
-                output_name_var=output_name_var,
-                output_dtype_var=output_dtype_var,
-            )
-        ]
-
-
-@register_op_adapter(SeriesDictSetItemOperator)
-class SeriesDictSetItemOperatorAdapter(SPEOperatorAdapter):
-    def generate_code(
-        self, op: SeriesDictSetItemOperator, context: SPECodeContext
-    ) -> List[str]:
-        input_var = context.get_input_tileable_variable(op.inputs[0])
-        output_var = context.get_output_tileable_variable(op.outputs[0])
-        key_var = self.translate_var(context, op.query_key)
-        value_var = self.translate_var(context, op.value)
-        output_name_var = self.translate_var(context, op.outputs[0].name)
-        output_dtype_var = context.register_operator_constants(op.outputs[0].dtype)
-        return [
-            _set_template.format(
-                input_var=input_var,
-                output_var=output_var,
-                key_var=key_var,
-                value_var=value_var,
-                output_name_var=output_name_var,
-                output_dtype_var=output_dtype_var,
-            )
-        ]
-
-
-@register_op_adapter(SeriesDictLengthOperator)
-class SeriesDictLengthOperatorAdapter(SPEOperatorAdapter):
-    def generate_code(
-        self, op: SeriesDictLengthOperator, context: SPECodeContext
-    ) -> List[str]:
-        input_var = context.get_input_tileable_variable(op.inputs[0])
-        output_var = context.get_output_tileable_variable(op.outputs[0])
-        output_name_var = self.translate_var(context, op.outputs[0].name)
-        output_dtype_var = context.register_operator_constants(op.outputs[0].dtype)
-        return [
-            _length_template.format(
-                input_var=input_var,
-                output_var=output_var,
-                output_name_var=output_name_var,
-                output_dtype_var=output_dtype_var,
-            )
-        ]
-
-
-@register_op_adapter(SeriesDictRemoveOperator)
-class SeriesDictRemoveOperatorAdapter(SPEOperatorAdapter):
-    def generate_code(
-        self, op: SeriesDictRemoveOperator, context: SPECodeContext
-    ) -> List[str]:
-        input_var = context.get_input_tileable_variable(op.inputs[0])
-        output_var = context.get_output_tileable_variable(op.outputs[0])
-        output_name_var = self.translate_var(context, op.outputs[0].name)
-        output_dtype_var = context.register_operator_constants(op.outputs[0].dtype)
-        key_var = self.translate_var(context, op.query_key)
-        ignore_key_error_var = self.translate_var(context, op.ignore_key_error)
-        return [
-            _remove_template.format(
-                input_var=input_var,
-                output_var=output_var,
-                key_var=key_var,
-                ignore_key_error_var=ignore_key_error_var,
-                output_name_var=output_name_var,
-                output_dtype_var=output_dtype_var,
-            )
-        ]
-
-
-@register_op_adapter(SeriesDictContainsOperator)
-class SeriesDictContainsOperatorAdapter(SPEOperatorAdapter):
-    def generate_code(
-        self, op: SeriesDictContainsOperator, context: SPECodeContext
-    ) -> List[str]:
-        input_var = context.get_input_tileable_variable(op.inputs[0])
-        output_var = context.get_output_tileable_variable(op.outputs[0])
-        output_name_var = self.translate_var(context, op.outputs[0].name)
-        output_dtype_var = context.register_operator_constants(op.outputs[0].dtype)
-        key_var = self.translate_var(context, op.query_key)
-        return [
-            _contains_template.format(
-                input_var=input_var,
-                output_var=output_var,
-                key_var=key_var,
-                output_name_var=output_name_var,
-                output_dtype_var=output_dtype_var,
-            )
-        ]
+@register_op_adapter(SeriesDictMethod)
+class SeriesDictMethodAdapter(SeriesTemplateMethodAdapter):
+    _templates = {
+        "contains": _contains_template,
+        "getitem": _get_template,
+        "len": _len_template,
+        "setitem": _set_template,
+        "remove": _remove_template,
+    }

maxframe/codegen/spe/dataframe/accessors/list_.py

@@ -12,18 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import List
-
-from .....dataframe.accessors.list_.getitem import SeriesListGetItemOperator
-from .....dataframe.accessors.list_.length import SeriesListLengthOperator
-from ...core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+from .....dataframe.accessors.list_.core import SeriesListMethod
+from ...core import register_op_adapter
+from .base import SeriesTemplateMethodAdapter
 
 _get_template = """
 def _inner_get(data):
     try:
-        return data[{index_var}]
+        return data[{query_index}]
     except IndexError:
-        if {ignore_index_error_var}:
+        if {ignore_index_error}:
             return None
         else:
             raise
@@ -32,49 +30,15 @@ def _inner_get(data):
 {output_var}.name = None
 """
 
-_length_template = """
+_len_template = """
 {output_var} = {input_var}.map(len, na_action="ignore").astype({output_dtype_var})
 {output_var}.name = None
 """
 
 
-@register_op_adapter(SeriesListGetItemOperator)
-class SeriesListGetItemOperatorAdapter(SPEOperatorAdapter):
-    def generate_code(
-        self, op: SeriesListGetItemOperator, context: SPECodeContext
-    ) -> List[str]:
-        input_var = context.get_input_tileable_variable(op.inputs[0])
-        output_var = context.get_output_tileable_variable(op.outputs[0])
-        index_var = self.translate_var(context, op.query_index)
-        output_name_var = self.translate_var(context, op.outputs[0].name)
-        ignore_index_error_var = self.translate_var(context, op.ignore_index_error)
-        output_dtype_var = context.register_operator_constants(op.outputs[0].dtype)
-        return [
-            _get_template.format(
-                input_var=input_var,
-                output_var=output_var,
-                index_var=index_var,
-                ignore_index_error_var=ignore_index_error_var,
-                output_name_var=output_name_var,
-                output_dtype_var=output_dtype_var,
-            )
-        ]
-
-
-@register_op_adapter(SeriesListLengthOperator)
-class SeriesListLengthOperatorAdapter(SPEOperatorAdapter):
-    def generate_code(
-        self, op: SeriesListLengthOperator, context: SPECodeContext
-    ) -> List[str]:
-        input_var = context.get_input_tileable_variable(op.inputs[0])
-        output_var = context.get_output_tileable_variable(op.outputs[0])
-        output_name_var = self.translate_var(context, op.outputs[0].name)
-        output_dtype_var = context.register_operator_constants(op.outputs[0].dtype)
-        return [
-            _length_template.format(
-                input_var=input_var,
-                output_var=output_var,
-                output_name_var=output_name_var,
-                output_dtype_var=output_dtype_var,
-            )
-        ]
+@register_op_adapter(SeriesListMethod)
+class SeriesListMethodAdapter(SeriesTemplateMethodAdapter):
+    _templates = {
+        "getitem": _get_template,
+        "len": _len_template,
+    }

maxframe/codegen/spe/dataframe/accessors/struct_.py

@@ -0,0 +1,28 @@
+# 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 .....dataframe.accessors.struct_.core import SeriesStructMethod
+from ...core import register_op_adapter
+from .base import SeriesTemplateMethodAdapter
+
+_field_template = """
+{output_var} = {input_var}.struct.field({name_or_index})
+"""
+
+
+@register_op_adapter(SeriesStructMethod)
+class SeriesStructMethodAdapter(SeriesTemplateMethodAdapter):
+    _templates = {
+        "field": _field_template,
+    }

maxframe/codegen/spe/dataframe/arithmetic.py

@@ -17,13 +17,15 @@ from typing import Dict, List, Type
 from ....core import ENTITY_TYPE
 from ....dataframe.arithmetic import (
     DataFrameAnd,
-    DataFrameAround,
+    DataFrameDot,
     DataFrameOr,
+    DataFrameRound,
     DataFrameXor,
 )
 from ....dataframe.arithmetic.core import DataFrameBinOp, DataFrameUnaryOp
 from ....dataframe.core import SERIES_TYPE
 from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+from ..utils import build_method_call_adapter
 
 
 @register_op_adapter(DataFrameUnaryOp)
@@ -34,7 +36,7 @@ class DataFrameUnaryFuncAdapter(SPEOperatorAdapter):
         inp_var = context.get_input_tileable_variable(op.inputs[0])
         res_var_name = context.get_output_tileable_variable(op.outputs[0])
         func = getattr(op, "_func_name")
-        if isinstance(op, DataFrameAround):
+        if isinstance(op, DataFrameRound):
             decimals_var = self.translate_var(context, op.decimals)
             return [f"{res_var_name} = {inp_var}.round({decimals_var})"]
         else:
@@ -82,3 +84,6 @@ class DataFrameBitwiseBinOpAdapter(SPEOperatorAdapter):
         res_var = context.get_output_tileable_variable(op.outputs[0])
         right_var = self._translate_call_args(context, rhs)[0]
         return [f"{res_var} = {left_var} {self._python_op[type(op)]} {right_var}"]
+
+
+DataFrameDotAdapter = build_method_call_adapter(DataFrameDot, "dot", "rhs")

maxframe/codegen/spe/dataframe/groupby.py

@@ -21,12 +21,15 @@ from ....dataframe.groupby.apply import GroupByApply
 from ....dataframe.groupby.apply_chunk import GroupByApplyChunk
 from ....dataframe.groupby.core import DataFrameGroupByOp
 from ....dataframe.groupby.cum import GroupByCumcount, GroupByCumReductionOperator
+from ....dataframe.groupby.expanding import GroupByExpandingAgg
 from ....dataframe.groupby.fill import GroupByFill
 from ....dataframe.groupby.getitem import GroupByIndex
 from ....dataframe.groupby.head import GroupByHead
+from ....dataframe.groupby.rolling import GroupByRollingAgg
 from ....dataframe.groupby.sample import GroupBySample
 from ....dataframe.groupby.transform import GroupByTransform
 from ....dataframe.utils import make_column_list
+from ....dataframe.window.rolling import Rolling
 from ....lib.version import parse as parse_version
 from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
 from ..utils import build_method_call_adapter
@@ -141,6 +144,8 @@ class GroupByApplyChunkAdapter(SPEGroupByOperatorAdapter):
 
 @register_op_adapter(GroupByCumReductionOperator)
 class GroupByCumReductionAdapter(SPEOperatorAdapter):
+    # legacy adapter kept for compatibility
+
     def generate_code(
         self, op: GroupByCumReductionOperator, context: SPECodeContext
     ) -> List[str]:
@@ -222,3 +227,86 @@ class GroupByTransformAdapter(SPEOperatorAdapter):
         args_list = self._translate_call_args(context, op.func, *op.args, **op.kwds)
         args = ", ".join(args_list)
         return [f"{res_var_name} = {input_var_name}.transform({args})"]
+
+
+@register_op_adapter(GroupByExpandingAgg)
+class GroupByExpandingAggAdapter(SPEGroupByOperatorAdapter):
+    def generate_code(
+        self, op: GroupByExpandingAgg, context: SPECodeContext
+    ) -> List[str]:
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+
+        by_call = self.build_groupby_call(context, op.groupby_params)
+        op_kwargs = (op.kwargs or dict()).copy()
+        op_kwargs.pop("cumcount", None)
+        func_kw_str = ", ".join(self._translate_call_args(context, **op_kwargs))
+
+        min_periods = op.window_params.get("min_periods", 1)
+        shift = op.window_params.get("shift", 0)
+        reverse_range = op.window_params.get("reverse_range", False)
+
+        if (
+            min_periods == 1
+            and shift == 0
+            and not reverse_range
+            and op.func in ("count", "sum", "prod", "min", "max")
+        ):
+            # can be simplified as cumxxx function
+            cumfunc = "cum" + op.func
+            return [
+                f"{res_var_name} = {input_var_name}.{by_call}.{cumfunc}({func_kw_str})"
+            ]
+
+        agg_func_str = self.translate_var(context, op.func)
+        min_periods_str = self.translate_var(context, min_periods)
+        inv_shift_str = self.translate_var(context, -shift)
+
+        # need to call groupby.apply() as groupby.expanding() is not a standard API
+        func_kw_str = (", " + func_kw_str) if func_kw_str else ""
+        lines = [
+            f"def _exp_fun_{res_var_name}(frame, **_):",
+            f'    func = {agg_func_str} if func != "prod" else lambda x: x.prod()',
+            f"    frame = frame.shift({inv_shift_str})" if shift else None,
+            f"    frame = frame.iloc[::-1]" if reverse_range else None,
+            f"    out_frame = frame.expanding(min_periods={min_periods_str}).agg(func{func_kw_str})",
+            f"    out_frame = out_frame.iloc[::-1]" if reverse_range else None,
+            f"    return out_frame",
+            f"{res_var_name} = {input_var_name}.{by_call}.apply("
+            f"_exp_fun_{res_var_name}, include_groups=False)",
+        ]
+        return [line for line in lines if line is not None]
+
+
+@register_op_adapter(GroupByRollingAgg)
+class GroupByRollingAggAdapter(SPEGroupByOperatorAdapter):
+    def generate_code(
+        self, op: GroupByRollingAgg, context: SPECodeContext
+    ) -> List[str]:
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+
+        by_call = self.build_groupby_call(context, op.groupby_params)
+        agg_func_str = self.translate_var(context, op.func)
+
+        window_params = op.window_params.copy()
+        shift = window_params.pop("shift", 0)
+        for key in Rolling._mf_specific_fields:
+            window_params.pop(key, None)
+
+        window_params_kw_str = ", ".join(
+            self._translate_call_args(context, **window_params)
+        )
+        func_kw_str = ", ".join(self._translate_call_args(context, **op.kwargs))
+        func_kw_str = (", " + func_kw_str) if func_kw_str else ""
+        inv_shift_str = self.translate_var(context, -shift)
+
+        # need to call groupby.apply() as groupby.rolling() is not a standard API
+        return [
+            f"def _roll_fun_{res_var_name}(frame, **_):",
+            f'    func = {agg_func_str} if func != "prod" else lambda x: x.prod()',
+            f"    frame = frame.shift({inv_shift_str})",
+            f"    return frame.rolling({window_params_kw_str}).agg(func{func_kw_str})",
+            f"{res_var_name} = {input_var_name}.{by_call}.apply("
+            f"_roll_fun_{res_var_name}, include_groups=False)",
+        ]