pylegend 0.13.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

pylegend/core/language/pandas_api/pandas_api_groupby_series.py

@@ -0,0 +1,357 @@
+# Copyright 2026 Goldman Sachs
+#
+# 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 copy
+import pandas as pd
+from pylegend._typing import (
+    TYPE_CHECKING,
+    PyLegendDict,
+    PyLegendOptional,
+    PyLegendSequence,
+    PyLegendTypeVar,
+    PyLegendUnion
+)
+from pylegend.core.language.pandas_api.pandas_api_aggregate_specification import PyLegendAggInput
+from pylegend.core.language.pandas_api.pandas_api_series import (
+    SupportsToPureExpression,
+    SupportsToSqlExpression
+)
+from pylegend.core.language.pandas_api.pandas_api_tds_row import PandasApiTdsRow
+from pylegend.core.language.shared.column_expressions import PyLegendColumnExpression
+from pylegend.core.language.shared.expression import (
+    PyLegendExpressionBooleanReturn,
+    PyLegendExpressionDateReturn,
+    PyLegendExpressionDateTimeReturn,
+    PyLegendExpressionFloatReturn,
+    PyLegendExpressionIntegerReturn,
+    PyLegendExpressionNumberReturn,
+    PyLegendExpressionStrictDateReturn,
+    PyLegendExpressionStringReturn
+)
+from pylegend.core.language.shared.primitives.boolean import PyLegendBoolean
+from pylegend.core.language.shared.primitives.date import PyLegendDate
+from pylegend.core.language.shared.primitives.datetime import PyLegendDateTime
+from pylegend.core.language.shared.primitives.float import PyLegendFloat
+from pylegend.core.language.shared.primitives.integer import PyLegendInteger
+from pylegend.core.language.shared.primitives.number import PyLegendNumber
+from pylegend.core.language.shared.primitives.primitive import (
+    PyLegendPrimitive,
+    PyLegendPrimitiveOrPythonPrimitive
+)
+from pylegend.core.language.shared.primitives.strictdate import PyLegendStrictDate
+from pylegend.core.language.shared.primitives.string import PyLegendString
+from pylegend.core.sql.metamodel import Expression, QuerySpecification
+from pylegend.core.tds.abstract.frames.base_tds_frame import BaseTdsFrame
+from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import PandasApiAppliedFunctionTdsFrame
+from pylegend.core.tds.pandas_api.frames.pandas_api_groupby_tds_frame import PandasApiGroupbyTdsFrame
+from pylegend.core.tds.result_handler import ResultHandler
+from pylegend.core.tds.tds_column import TdsColumn
+from pylegend.core.tds.tds_frame import FrameToPureConfig, FrameToSqlConfig
+from pylegend.extensions.tds.result_handler import PandasDfReadConfig
+
+if TYPE_CHECKING:
+    from pylegend.core.tds.pandas_api.frames.pandas_api_tds_frame import PandasApiTdsFrame
+
+__all__: PyLegendSequence[str] = [
+    "GroupbySeries",
+    "BooleanGroupbySeries",
+    "StringGroupbySeries",
+    "NumberGroupbySeries",
+    "IntegerGroupbySeries",
+    "FloatGroupbySeries",
+    "DateGroupbySeries",
+    "DateTimeGroupbySeries",
+    "StrictDateGroupbySeries",
+]
+
+R = PyLegendTypeVar('R')
+
+
+class GroupbySeries(PyLegendColumnExpression, PyLegendPrimitive, BaseTdsFrame):
+    _base_groupby_frame: PandasApiGroupbyTdsFrame
+    _applied_function_frame: PyLegendOptional[PandasApiAppliedFunctionTdsFrame]
+
+    def __init__(self, base_groupby_frame: PandasApiGroupbyTdsFrame):
+        selected_columns = base_groupby_frame.get_selected_columns()
+        assert selected_columns is not None and len(selected_columns) == 1, (
+            "To initialize a GroupbySeries object, exactly one column must be selected, "
+            f"but got selected columns: {[str(col) for col in selected_columns] if selected_columns is not None else None}"
+        )
+
+        row = PandasApiTdsRow.from_tds_frame("c", base_groupby_frame.base_frame())
+        PyLegendColumnExpression.__init__(self, row=row, column=selected_columns[0].get_name())
+
+        self._base_groupby_frame: PandasApiGroupbyTdsFrame = base_groupby_frame
+        self._applied_function_frame = None
+
+    @property
+    def applied_function_frame(self) -> PyLegendOptional[PandasApiAppliedFunctionTdsFrame]:
+        return self._applied_function_frame
+
+    @applied_function_frame.setter
+    def applied_function_frame(self, value: PandasApiAppliedFunctionTdsFrame) -> None:
+        self._applied_function_frame = value
+
+    def _raise_exception_if_no_function_applied(self) -> PandasApiAppliedFunctionTdsFrame:
+        if self._applied_function_frame is None:
+            raise RuntimeError(
+                "The 'groupby' function requires at least one operation to be performed right after it (e.g. aggregate, rank)"
+            )
+        return self._applied_function_frame
+
+    def get_base_frame(self) -> "PandasApiGroupbyTdsFrame":
+        return self._base_groupby_frame
+
+    def to_sql_expression(
+            self,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        applied_function_frame = self._raise_exception_if_no_function_applied()
+        applied_func = applied_function_frame.get_applied_function()
+        if isinstance(applied_func, SupportsToSqlExpression):
+            return applied_func.to_sql_expression(frame_name_to_base_query_map, config)
+
+        raise NotImplementedError(  # pragma: no cover
+            f"The '{applied_func.name()}' function cannot provide a SQL expression"
+        )
+
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        applied_function_frame = self._raise_exception_if_no_function_applied()
+        applied_func = applied_function_frame.get_applied_function()
+        if isinstance(applied_func, SupportsToPureExpression):
+            return applied_func.to_pure_expression(config)
+
+        raise NotImplementedError(  # pragma: no cover
+            f"The '{applied_func.name()}' function cannot provide a pure expression"
+        )
+
+    def columns(self) -> PyLegendSequence[TdsColumn]:
+        applied_function_frame = self._raise_exception_if_no_function_applied()
+        return applied_function_frame.columns()
+
+    def to_sql_query(self, config: FrameToSqlConfig = FrameToSqlConfig()) -> str:
+        applied_function_frame = self._raise_exception_if_no_function_applied()
+        return applied_function_frame.to_sql_query(config)
+
+    def to_pure_query(self, config: FrameToPureConfig = FrameToPureConfig()) -> str:
+        applied_function_frame = self._raise_exception_if_no_function_applied()
+        return applied_function_frame.to_pure_query(config)
+
+    def execute_frame(
+            self,
+            result_handler: ResultHandler[R],
+            chunk_size: PyLegendOptional[int] = None
+    ) -> R:  # pragma: no cover
+        applied_function_frame = self._raise_exception_if_no_function_applied()
+        return applied_function_frame.execute_frame(result_handler, chunk_size)
+
+    def execute_frame_to_string(
+            self,
+            chunk_size: PyLegendOptional[int] = None
+    ) -> str:  # pragma: no cover
+        applied_function_frame = self._raise_exception_if_no_function_applied()
+        return applied_function_frame.execute_frame_to_string(chunk_size)
+
+    def execute_frame_to_pandas_df(
+            self,
+            chunk_size: PyLegendOptional[int] = None,
+            pandas_df_read_config: PandasDfReadConfig = PandasDfReadConfig()
+    ) -> pd.DataFrame:  # pragma: no cover
+        applied_function_frame = self._raise_exception_if_no_function_applied()
+        return applied_function_frame.execute_frame_to_pandas_df(chunk_size, pandas_df_read_config)
+
+    def to_sql_query_object(self, config: FrameToSqlConfig) -> QuerySpecification:
+        applied_function_frame = self._raise_exception_if_no_function_applied()
+        return applied_function_frame.to_sql_query_object(config)
+
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        applied_function_frame = self._raise_exception_if_no_function_applied()
+        return applied_function_frame.to_pure(config)
+
+    def get_all_tds_frames(self) -> PyLegendSequence["BaseTdsFrame"]:
+        applied_function_frame = self._raise_exception_if_no_function_applied()
+        return applied_function_frame.get_all_tds_frames()
+
+    def aggregate(
+            self,
+            func: PyLegendAggInput,
+            axis: PyLegendUnion[int, str] = 0,
+            *args: PyLegendPrimitiveOrPythonPrimitive,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        new_series = copy.copy(self)
+        if new_series.applied_function_frame is None:
+            return new_series.get_base_frame().aggregate(func, axis, *args, **kwargs)
+        else:
+            return new_series.applied_function_frame.aggregate(func, axis, *args, **kwargs)
+
+    def agg(
+            self,
+            func: PyLegendAggInput,
+            axis: PyLegendUnion[int, str] = 0,
+            *args: PyLegendPrimitiveOrPythonPrimitive,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        return self.aggregate(func, axis, *args, **kwargs)
+
+    def sum(
+        self,
+        numeric_only: bool = False,
+        min_count: int = 0,
+        engine: PyLegendOptional[str] = None,
+        engine_kwargs: PyLegendOptional[PyLegendDict[str, bool]] = None,
+    ) -> "PandasApiTdsFrame":
+        if numeric_only is not False:
+            raise NotImplementedError("numeric_only=True is not currently supported in sum function.")
+        if min_count != 0:
+            raise NotImplementedError(f"min_count must be 0 in sum function, but got: {min_count}")
+        if engine is not None:
+            raise NotImplementedError("engine parameter is not supported in sum function.")
+        if engine_kwargs is not None:
+            raise NotImplementedError("engine_kwargs parameter is not supported in sum function.")
+        return self.aggregate("sum", 0)
+
+    def mean(
+        self,
+        numeric_only: bool = False,
+        engine: PyLegendOptional[str] = None,
+        engine_kwargs: PyLegendOptional[PyLegendDict[str, bool]] = None,
+    ) -> "PandasApiTdsFrame":
+        if numeric_only is not False:
+            raise NotImplementedError("numeric_only=True is not currently supported in mean function.")
+        if engine is not None:
+            raise NotImplementedError("engine parameter is not supported in mean function.")
+        if engine_kwargs is not None:
+            raise NotImplementedError("engine_kwargs parameter is not supported in mean function.")
+        return self.aggregate("mean", 0)
+
+    def min(
+        self,
+        numeric_only: bool = False,
+        min_count: int = -1,
+        engine: PyLegendOptional[str] = None,
+        engine_kwargs: PyLegendOptional[PyLegendDict[str, bool]] = None,
+    ) -> "PandasApiTdsFrame":
+        if numeric_only is not False:
+            raise NotImplementedError("numeric_only=True is not currently supported in min function.")
+        if min_count != -1:
+            raise NotImplementedError(f"min_count must be -1 (default) in min function, but got: {min_count}")
+        if engine is not None:
+            raise NotImplementedError("engine parameter is not supported in min function.")
+        if engine_kwargs is not None:
+            raise NotImplementedError("engine_kwargs parameter is not supported in min function.")
+        return self.aggregate("min", 0)
+
+    def max(
+        self,
+        numeric_only: bool = False,
+        min_count: int = -1,
+        engine: PyLegendOptional[str] = None,
+        engine_kwargs: PyLegendOptional[PyLegendDict[str, bool]] = None,
+    ) -> "PandasApiTdsFrame":
+        if numeric_only is not False:
+            raise NotImplementedError("numeric_only=True is not currently supported in max function.")
+        if min_count != -1:
+            raise NotImplementedError(f"min_count must be -1 (default) in max function, but got: {min_count}")
+        if engine is not None:
+            raise NotImplementedError("engine parameter is not supported in max function.")
+        if engine_kwargs is not None:
+            raise NotImplementedError("engine_kwargs parameter is not supported in max function.")
+        return self.aggregate("max", 0)
+
+    def std(
+        self,
+        ddof: int = 1,
+        engine: PyLegendOptional[str] = None,
+        engine_kwargs: PyLegendOptional[PyLegendDict[str, bool]] = None,
+        numeric_only: bool = False,
+    ) -> "PandasApiTdsFrame":
+        if ddof != 1:
+            raise NotImplementedError(f"Only ddof=1 (Sample Standard Deviation) is supported in std function, but got: {ddof}")
+        if engine is not None:
+            raise NotImplementedError("engine parameter is not supported in std function.")
+        if engine_kwargs is not None:
+            raise NotImplementedError("engine_kwargs parameter is not supported in std function.")
+        if numeric_only is not False:
+            raise NotImplementedError("numeric_only=True is not currently supported in std function.")
+        return self.aggregate("std", 0)
+
+    def var(
+        self,
+        ddof: int = 1,
+        engine: PyLegendOptional[str] = None,
+        engine_kwargs: PyLegendOptional[PyLegendDict[str, bool]] = None,
+        numeric_only: bool = False,
+    ) -> "PandasApiTdsFrame":
+        if ddof != 1:
+            raise NotImplementedError(f"Only ddof=1 (Sample Variance) is supported in var function, but got: {ddof}")
+        if engine is not None:
+            raise NotImplementedError("engine parameter is not supported in var function.")
+        if engine_kwargs is not None:
+            raise NotImplementedError("engine_kwargs parameter is not supported in var function.")
+        if numeric_only is not False:
+            raise NotImplementedError("numeric_only=True is not currently supported in var function.")
+        return self.aggregate("var", 0)
+
+    def count(self) -> "PandasApiTdsFrame":
+        return self.aggregate("count", 0)
+
+
+class BooleanGroupbySeries(GroupbySeries, PyLegendBoolean, PyLegendExpressionBooleanReturn):
+    def __init__(self, base_frame: "PandasApiGroupbyTdsFrame"):
+        super().__init__(base_frame)  # pragma: no cover (Boolean column not supported in PURE)
+        PyLegendBoolean.__init__(self, self)  # pragma: no cover (Boolean column not supported in PURE)
+
+
+class StringGroupbySeries(GroupbySeries, PyLegendString, PyLegendExpressionStringReturn):
+    def __init__(self, base_frame: "PandasApiGroupbyTdsFrame"):
+        super().__init__(base_frame)
+        PyLegendString.__init__(self, self)
+
+
+class NumberGroupbySeries(GroupbySeries, PyLegendNumber, PyLegendExpressionNumberReturn):
+    def __init__(self, base_frame: "PandasApiGroupbyTdsFrame"):
+        super().__init__(base_frame)
+        PyLegendNumber.__init__(self, self)
+
+
+class IntegerGroupbySeries(NumberGroupbySeries, PyLegendInteger, PyLegendExpressionIntegerReturn):
+    def __init__(self, base_frame: "PandasApiGroupbyTdsFrame"):
+        super().__init__(base_frame)
+        PyLegendInteger.__init__(self, self)
+
+
+class FloatGroupbySeries(NumberGroupbySeries, PyLegendFloat, PyLegendExpressionFloatReturn):
+    def __init__(self, base_frame: "PandasApiGroupbyTdsFrame"):
+        super().__init__(base_frame)
+        PyLegendFloat.__init__(self, self)
+
+
+class DateGroupbySeries(GroupbySeries, PyLegendDate, PyLegendExpressionDateReturn):
+    def __init__(self, base_frame: "PandasApiGroupbyTdsFrame"):
+        super().__init__(base_frame)
+        PyLegendDate.__init__(self, self)
+
+
+class DateTimeGroupbySeries(DateGroupbySeries, PyLegendDateTime, PyLegendExpressionDateTimeReturn):
+    def __init__(self, base_frame: "PandasApiGroupbyTdsFrame"):
+        super().__init__(base_frame)
+        PyLegendDateTime.__init__(self, self)
+
+
+class StrictDateGroupbySeries(DateGroupbySeries, PyLegendStrictDate, PyLegendExpressionStrictDateReturn):
+    def __init__(self, base_frame: "PandasApiGroupbyTdsFrame"):
+        super().__init__(base_frame)
+        PyLegendStrictDate.__init__(self, self)

pylegend/core/language/pandas_api/pandas_api_series.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, runtime_checkable, Protocol
 
 import pandas as pd
 
@@ -22,8 +22,10 @@ from pylegend._typing import (
 from pylegend._typing import (
     PyLegendSequence,
     PyLegendOptional,
-    PyLegendTypeVar
+    PyLegendTypeVar,
+    PyLegendUnion
 )
+from pylegend.core.language.pandas_api.pandas_api_aggregate_specification import PyLegendAggInput
 from pylegend.core.language.pandas_api.pandas_api_tds_row import PandasApiTdsRow
 from pylegend.core.language.shared.column_expressions import PyLegendColumnExpression
 from pylegend.core.language.shared.expression import (
@@ -42,7 +44,7 @@ from pylegend.core.language.shared.primitives.datetime import PyLegendDateTime
 from pylegend.core.language.shared.primitives.float import PyLegendFloat
 from pylegend.core.language.shared.primitives.integer import PyLegendInteger
 from pylegend.core.language.shared.primitives.number import PyLegendNumber
-from pylegend.core.language.shared.primitives.primitive import PyLegendPrimitive
+from pylegend.core.language.shared.primitives.primitive import PyLegendPrimitive, PyLegendPrimitiveOrPythonPrimitive
 from pylegend.core.language.shared.primitives.strictdate import PyLegendStrictDate
 from pylegend.core.language.shared.primitives.string import PyLegendString
 from pylegend.core.sql.metamodel import (
@@ -50,6 +52,8 @@ from pylegend.core.sql.metamodel import (
 )
 from pylegend.core.sql.metamodel import QuerySpecification
 from pylegend.core.tds.abstract.frames.base_tds_frame import BaseTdsFrame
+from pylegend.core.tds.pandas_api.frames.functions.filter import PandasApiFilterFunction
+from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import PandasApiAppliedFunctionTdsFrame
 from pylegend.core.tds.result_handler import ResultHandler
 from pylegend.core.tds.tds_column import TdsColumn
 from pylegend.core.tds.tds_frame import FrameToPureConfig
@@ -60,19 +64,39 @@ if TYPE_CHECKING:
     from pylegend.core.tds.pandas_api.frames.pandas_api_tds_frame import PandasApiTdsFrame
 
 __all__: PyLegendSequence[str] = [
-    "Series"
+    "Series",
+    "SupportsToSqlExpression",
+    "SupportsToPureExpression",
 ]
 
 R = PyLegendTypeVar('R')
 
 
+@runtime_checkable
+class SupportsToSqlExpression(Protocol):
+    def to_sql_expression(
+            self,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        ...
+
+
+@runtime_checkable
+class SupportsToPureExpression(Protocol):
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        ...
+
+
 class Series(PyLegendColumnExpression, PyLegendPrimitive, BaseTdsFrame):
     def __init__(self, base_frame: "PandasApiTdsFrame", column: str):
         row = PandasApiTdsRow.from_tds_frame("c", base_frame)
         PyLegendColumnExpression.__init__(self, row=row, column=column)
 
         self.__base_frame = base_frame
-        self._filtered_frame = base_frame.filter(items=[column])
+        filtered = base_frame.filter(items=[column])
+        assert isinstance(filtered, PandasApiAppliedFunctionTdsFrame)
+        self._filtered_frame: PandasApiAppliedFunctionTdsFrame = filtered
 
     def value(self) -> PyLegendColumnExpression:
         return self
@@ -85,9 +109,27 @@ class Series(PyLegendColumnExpression, PyLegendPrimitive, BaseTdsFrame):
             frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
             config: FrameToSqlConfig
     ) -> Expression:
+        applied_func = self._filtered_frame.get_applied_function()
+        if not isinstance(applied_func, PandasApiFilterFunction):  # pragma: no cover
+            if isinstance(applied_func, SupportsToSqlExpression):
+                return applied_func.to_sql_expression(frame_name_to_base_query_map, config)
+            else:
+                raise NotImplementedError(
+                    f"The '{applied_func.name()}' function cannot provide a SQL expression"
+                )
+
         return super().to_sql_expression(frame_name_to_base_query_map, config)
 
     def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        applied_func = self._filtered_frame.get_applied_function()
+        if not isinstance(applied_func, PandasApiFilterFunction):  # pragma: no cover
+            if isinstance(applied_func, SupportsToPureExpression):
+                return applied_func.to_pure_expression(config)
+            else:
+                raise NotImplementedError(
+                    f"The '{applied_func.name()}' function cannot provide a pure expression"
+                )
+
         return super().to_pure_expression(config)
 
     def columns(self) -> PyLegendSequence[TdsColumn]:
@@ -120,13 +162,165 @@ class Series(PyLegendColumnExpression, PyLegendPrimitive, BaseTdsFrame):
         return self._filtered_frame.execute_frame_to_pandas_df(chunk_size, pandas_df_read_config)  # pragma: no cover
 
     def to_sql_query_object(self, config: FrameToSqlConfig) -> QuerySpecification:
-        return self._filtered_frame.to_sql_query_object(config)  # type: ignore
+        return self._filtered_frame.to_sql_query_object(config)
 
     def to_pure(self, config: FrameToPureConfig) -> str:
-        return self._filtered_frame.to_pure(config)  # type: ignore
+        return self._filtered_frame.to_pure(config)
 
     def get_all_tds_frames(self) -> PyLegendSequence["BaseTdsFrame"]:
-        return self._filtered_frame.get_all_tds_frames()  # type: ignore
+        return self._filtered_frame.get_all_tds_frames()
+
+    def aggregate(
+            self,
+            func: PyLegendAggInput,
+            axis: PyLegendUnion[int, str] = 0,
+            *args: PyLegendPrimitiveOrPythonPrimitive,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        return self._filtered_frame.aggregate(func, axis, *args, **kwargs)
+
+    def agg(
+            self,
+            func: PyLegendAggInput,
+            axis: PyLegendUnion[int, str] = 0,
+            *args: PyLegendPrimitiveOrPythonPrimitive,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        return self.aggregate(func, axis, *args, **kwargs)
+
+    def sum(
+            self,
+            axis: PyLegendUnion[int, str] = 0,
+            skipna: bool = True,
+            numeric_only: bool = False,
+            min_count: int = 0,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        if axis not in [0, "index"]:
+            raise NotImplementedError(f"The 'axis' parameter must be 0 or 'index' in sum function, but got: {axis}")
+        if skipna is not True:
+            raise NotImplementedError("skipna=False is not currently supported in sum function. "
+                                      "SQL aggregation ignores nulls by default.")
+        if numeric_only is not False:
+            raise NotImplementedError("numeric_only=True is not currently supported in sum function.")
+        if min_count != 0:
+            raise NotImplementedError(f"min_count must be 0 in sum function, but got: {min_count}")
+        if len(kwargs) > 0:
+            raise NotImplementedError(
+                f"Additional keyword arguments not supported in sum function: {list(kwargs.keys())}")
+        return self.aggregate("sum", 0)
+
+    def mean(
+            self,
+            axis: PyLegendUnion[int, str] = 0,
+            skipna: bool = True,
+            numeric_only: bool = False,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        if axis not in [0, "index"]:
+            raise NotImplementedError(f"The 'axis' parameter must be 0 or 'index' in mean function, but got: {axis}")
+        if skipna is not True:
+            raise NotImplementedError("skipna=False is not currently supported in mean function.")
+        if numeric_only is not False:
+            raise NotImplementedError("numeric_only=True is not currently supported in mean function.")
+        if len(kwargs) > 0:
+            raise NotImplementedError(
+                f"Additional keyword arguments not supported in mean function: {list(kwargs.keys())}")
+        return self.aggregate("mean", 0)
+
+    def min(
+            self,
+            axis: PyLegendUnion[int, str] = 0,
+            skipna: bool = True,
+            numeric_only: bool = False,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        if axis not in [0, "index"]:
+            raise NotImplementedError(f"The 'axis' parameter must be 0 or 'index' in min function, but got: {axis}")
+        if skipna is not True:
+            raise NotImplementedError("skipna=False is not currently supported in min function.")
+        if numeric_only is not False:
+            raise NotImplementedError("numeric_only=True is not currently supported in min function.")
+        if len(kwargs) > 0:
+            raise NotImplementedError(
+                f"Additional keyword arguments not supported in min function: {list(kwargs.keys())}")
+        return self.aggregate("min", 0)
+
+    def max(
+            self,
+            axis: PyLegendUnion[int, str] = 0,
+            skipna: bool = True,
+            numeric_only: bool = False,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        if axis not in [0, "index"]:
+            raise NotImplementedError(f"The 'axis' parameter must be 0 or 'index' in max function, but got: {axis}")
+        if skipna is not True:
+            raise NotImplementedError("skipna=False is not currently supported in max function.")
+        if numeric_only is not False:
+            raise NotImplementedError("numeric_only=True is not currently supported in max function.")
+        if len(kwargs) > 0:
+            raise NotImplementedError(
+                f"Additional keyword arguments not supported in max function: {list(kwargs.keys())}")
+        return self.aggregate("max", 0)
+
+    def std(
+            self,
+            axis: PyLegendUnion[int, str] = 0,
+            skipna: bool = True,
+            ddof: int = 1,
+            numeric_only: bool = False,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        if axis not in [0, "index"]:
+            raise NotImplementedError(f"The 'axis' parameter must be 0 or 'index' in std function, but got: {axis}")
+        if skipna is not True:
+            raise NotImplementedError("skipna=False is not currently supported in std function.")
+        if ddof != 1:
+            raise NotImplementedError(
+                f"Only ddof=1 (Sample Standard Deviation) is supported in std function, but got: {ddof}")
+        if numeric_only is not False:
+            raise NotImplementedError("numeric_only=True is not currently supported in std function.")
+        if len(kwargs) > 0:
+            raise NotImplementedError(
+                f"Additional keyword arguments not supported in std function: {list(kwargs.keys())}")
+        return self.aggregate("std", 0)
+
+    def var(
+            self,
+            axis: PyLegendUnion[int, str] = 0,
+            skipna: bool = True,
+            ddof: int = 1,
+            numeric_only: bool = False,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        if axis not in [0, "index"]:
+            raise NotImplementedError(f"The 'axis' parameter must be 0 or 'index' in var function, but got: {axis}")
+        if skipna is not True:
+            raise NotImplementedError("skipna=False is not currently supported in var function.")
+        if ddof != 1:
+            raise NotImplementedError(f"Only ddof=1 (Sample Variance) is supported in var function, but got: {ddof}")
+        if numeric_only is not False:
+            raise NotImplementedError("numeric_only=True is not currently supported in var function.")
+        if len(kwargs) > 0:
+            raise NotImplementedError(
+                f"Additional keyword arguments not supported in var function: {list(kwargs.keys())}")
+        return self.aggregate("var", 0)
+
+    def count(
+            self,
+            axis: PyLegendUnion[int, str] = 0,
+            numeric_only: bool = False,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        if axis not in [0, "index"]:
+            raise NotImplementedError(f"The 'axis' parameter must be 0 or 'index' in count function, but got: {axis}")
+        if numeric_only is not False:
+            raise NotImplementedError("numeric_only=True is not currently supported in count function.")
+        if len(kwargs) > 0:
+            raise NotImplementedError(
+                f"Additional keyword arguments not supported in count function: {list(kwargs.keys())}")
+        return self.aggregate("count", 0)
 
 
 class BooleanSeries(Series, PyLegendBoolean, PyLegendExpressionBooleanReturn):  # type: ignore

pylegend/core/tds/pandas_api/frames/functions/aggregate_function.py

@@ -100,7 +100,7 @@ class AggregateFunction(PandasApiAppliedFunction):
 
         if isinstance(self.__base_frame, PandasApiGroupbyTdsFrame):
             columns_to_retain: PyLegendList[str] = [
-                db_extension.quote_identifier(x) for x in self.__base_frame.grouping_column_name_list()
+                db_extension.quote_identifier(x.get_name()) for x in self.__base_frame.get_grouping_columns()
             ]
             new_cols_with_index: PyLegendList[PyLegendTuple[int, "SelectItem"]] = []
             for col in new_query.select.selectItems:
@@ -127,8 +127,8 @@ class AggregateFunction(PandasApiAppliedFunction):
         if isinstance(self.__base_frame, PandasApiGroupbyTdsFrame):
             tds_row = PandasApiTdsRow.from_tds_frame("r", self.base_frame())
             new_query.groupBy = [
-                (lambda x: x[c])(tds_row).to_sql_expression({"r": new_query}, config)
-                for c in self.__base_frame.grouping_column_name_list()
+                (lambda x: x[c.get_name()])(tds_row).to_sql_expression({"r": new_query}, config)
+                for c in self.__base_frame.get_grouping_columns()
             ]
 
         return new_query
@@ -149,8 +149,8 @@ class AggregateFunction(PandasApiAppliedFunction):
 
         if isinstance(self.__base_frame, PandasApiGroupbyTdsFrame):
             group_strings = []
-            for col_name in self.__base_frame.grouping_column_name_list():
-                group_strings.append(escape_column_name(col_name))
+            for col in self.__base_frame.get_grouping_columns():
+                group_strings.append(escape_column_name(col.get_name()))
 
             pure_expression = (
                 f"{self.base_frame().to_pure(config)}{config.separator(1)}" + f"->groupBy({config.separator(2)}"
@@ -182,7 +182,8 @@ class AggregateFunction(PandasApiAppliedFunction):
 
         if isinstance(self.__base_frame, PandasApiGroupbyTdsFrame):
             base_cols_map = {c.get_name(): c for c in self.base_frame().columns()}
-            for group_col_name in self.__base_frame.grouping_column_name_list():
+            for group_col in self.__base_frame.get_grouping_columns():
+                group_col_name = group_col.get_name()
                 if group_col_name in base_cols_map:
                     new_columns.append(base_cols_map[group_col_name].copy())
 
@@ -231,6 +232,10 @@ class AggregateFunction(PandasApiAppliedFunction):
 
         tds_row = PandasApiTdsRow.from_tds_frame("r", self.base_frame())
 
+        group_cols: set[str] = set()
+        if isinstance(self.__base_frame, PandasApiGroupbyTdsFrame):
+            group_cols = set([col.get_name() for col in self.__base_frame.get_grouping_columns()])
+
         for column_name, agg_input in normalized_func.items():
             mapper_function: PyLegendCallable[[PandasApiTdsRow], PyLegendPrimitiveOrPythonPrimitive] = eval(
                 f'lambda r: r["{column_name}"]'
@@ -259,7 +264,12 @@ class AggregateFunction(PandasApiAppliedFunction):
                 normalized_agg_func = self.__normalize_agg_func_to_lambda_function(agg_input)
                 agg_result = normalized_agg_func(collection)
 
-                self.__aggregates_list.append((column_name, map_result, agg_result))
+                if column_name in group_cols:
+                    alias = self._generate_column_alias(column_name, agg_input, 0)
+                else:
+                    alias = column_name
+
+                self.__aggregates_list.append((alias, map_result, agg_result))
 
         return True
 
@@ -274,13 +284,13 @@ class AggregateFunction(PandasApiAppliedFunction):
         all_cols = [col.get_name() for col in self.base_frame().columns()]
 
         if isinstance(self.__base_frame, PandasApiGroupbyTdsFrame):
-            group_cols = set(self.__base_frame.grouping_column_name_list())
+            group_cols = set([col.get_name() for col in self.__base_frame.get_grouping_columns()])
 
-            selected_cols = self.__base_frame.selected_columns()
+            selected_cols = self.__base_frame.get_selected_columns()
 
             if selected_cols is not None:
-                validation_columns = selected_cols
-                default_broadcast_columns = selected_cols
+                validation_columns = [col.get_name() for col in selected_cols]
+                default_broadcast_columns = [col.get_name() for col in selected_cols]
             else:
                 validation_columns = all_cols
                 default_broadcast_columns = [c for c in all_cols if c not in group_cols]

pylegend/core/tds/pandas_api/frames/pandas_api_applied_function_tds_frame.py

@@ -85,3 +85,6 @@ class PandasApiAppliedFunctionTdsFrame(PandasApiBaseTdsFrame):
             for x in [self.__applied_function.base_frame()] + self.__applied_function.tds_frame_parameters()
             for y in x.get_all_tds_frames()
         ] + [self]
+
+    def get_applied_function(self) -> PandasApiAppliedFunction:
+        return self.__applied_function

pylegend/core/tds/pandas_api/frames/pandas_api_base_tds_frame.py

@@ -15,7 +15,7 @@
 import copy
 from abc import ABCMeta, abstractmethod
 from datetime import date, datetime
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, overload
 
 from typing_extensions import Concatenate
 
@@ -96,6 +96,14 @@ class PandasApiBaseTdsFrame(PandasApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
             return [c.copy() for c in self.__columns]
         return self._transformed_frame.columns()
 
+    @overload  # type: ignore[override]
+    def __getitem__(self, key: str) -> "Series":
+        ...
+
+    @overload
+    def __getitem__(self, key: PyLegendList[str]) -> "PandasApiTdsFrame":
+        ...
+
     def __getitem__(
             self,
             key: PyLegendUnion[str, PyLegendList[str], PyLegendBoolean]
@@ -665,7 +673,7 @@ class PandasApiBaseTdsFrame(PandasApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
             # Compute row callable via func on the Series
             def _row_callable(
                     _row: PandasApiTdsRow,
-                    _s: Series = series,  # type: ignore
+                    _s: Series = series,
                     _a: PyLegendTuple[PyLegendPrimitiveOrPythonPrimitive, ...] = args,
                     _k: PyLegendPrimitiveOrPythonPrimitive = kwargs  # type: ignore
             ) -> PyLegendPrimitiveOrPythonPrimitive:

pylegend/core/tds/pandas_api/frames/pandas_api_groupby_tds_frame.py

@@ -11,21 +11,24 @@
 # 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 overload
 
 from pylegend._typing import (
     PyLegendOptional,
     PyLegendUnion,
     PyLegendList,
     PyLegendDict,
+    PyLegendSet,
     TYPE_CHECKING,
 )
 from pylegend.core.language.pandas_api.pandas_api_aggregate_specification import PyLegendAggInput
 from pylegend.core.language.shared.primitives.primitive import PyLegendPrimitiveOrPythonPrimitive
 from pylegend.core.tds.pandas_api.frames.pandas_api_base_tds_frame import PandasApiBaseTdsFrame
+from pylegend.core.tds.tds_column import TdsColumn
 
 if TYPE_CHECKING:
     from pylegend.core.tds.pandas_api.frames.pandas_api_tds_frame import PandasApiTdsFrame
+    from pylegend.core.language.pandas_api.pandas_api_groupby_series import GroupbySeries
 
 
 class PandasApiGroupbyTdsFrame:
@@ -38,8 +41,8 @@ class PandasApiGroupbyTdsFrame:
     __observed: bool
     __dropna: bool
 
-    __grouping_column_name_list: PyLegendList[str]
-    __selected_columns: PyLegendOptional[PyLegendList[str]]
+    __grouping_columns: PyLegendList[TdsColumn]
+    __selected_columns: PyLegendOptional[PyLegendList[TdsColumn]]
 
     @classmethod
     def name(cls) -> str:
@@ -101,39 +104,65 @@ class PandasApiGroupbyTdsFrame:
                 f"but got: {self.__dropna} (type: {type(self.__dropna).__name__})"
             )
 
-        input_cols: PyLegendList[str] = []
+        input_cols: PyLegendSet[str]
         if isinstance(self.__by, str):
-            input_cols = [self.__by]
+            input_cols = set([self.__by])
         elif isinstance(self.__by, list):
-            input_cols = self.__by
+            input_cols = set(self.__by)
         else:
             raise TypeError(
                 f"The 'by' parameter in groupby function must be a string or a list of strings."
                 f"but got: {self.__by} (type: {type(self.__by).__name__})"
-            )
+            )  # pragma: no cover
+        group_by_names: PyLegendList[str]
+        if isinstance(self.__by, str):
+            group_by_names = [self.__by]
+        elif isinstance(self.__by, list):
+            group_by_names = self.__by
+        else:
+            raise TypeError(
+                f"The 'by' parameter in groupby function must be a string or a list of strings."
+                f"but got: {self.__by} (type: {type(self.__by).__name__})"
+            )  # pragma: no cover
 
-        if len(input_cols) == 0:
+        if len(group_by_names) == 0:
             raise ValueError("The 'by' parameter in groupby function must contain at least one column name.")
 
-        available_columns = {c.get_name() for c in self.__base_frame.columns()}
-        missing_cols = [col for col in input_cols if col not in available_columns]
+        base_col_map = {col.get_name(): col for col in self.__base_frame.columns()}
+
+        self.__grouping_columns = [
+            base_col_map[name]
+            for name in group_by_names
+            if name in base_col_map
+        ]
 
-        if len(missing_cols) > 0:
+        if len(self.__grouping_columns) < len(input_cols):
+            available_columns = {c.get_name() for c in self.__base_frame.columns()}
+            missing_cols = [col for col in input_cols if col not in available_columns]
             raise KeyError(
                 f"Column(s) {missing_cols} in groupby function's provided columns list "
                 f"do not exist in the current frame. "
                 f"Current frame columns: {sorted(available_columns)}"
             )
 
-        self.__grouping_column_name_list = input_cols.copy()
+    @overload
+    def __getitem__(self, key: str) -> "GroupbySeries":
+        ...
+
+    @overload
+    def __getitem__(self, key: PyLegendList[str]) -> "PandasApiGroupbyTdsFrame":
+        ...
 
-    def __getitem__(self, item: PyLegendUnion[str, PyLegendList[str]]) -> "PandasApiGroupbyTdsFrame":
-        columns_to_select: PyLegendList[str] = []
+    def __getitem__(
+            self,
+            item: PyLegendUnion[str, PyLegendList[str]]
+    ) -> PyLegendUnion["PandasApiGroupbyTdsFrame", "GroupbySeries"]:
+        columns_to_select: PyLegendSet[str]
 
         if isinstance(item, str):
-            columns_to_select = [item]
+            columns_to_select = set([item])
         elif isinstance(item, list):
-            columns_to_select = item
+            columns_to_select = set(item)
         else:
             raise TypeError(
                 f"Column selection after groupby function must be a string or a list of strings, "
@@ -143,10 +172,12 @@ class PandasApiGroupbyTdsFrame:
         if len(columns_to_select) == 0:
             raise ValueError("When performing column selection after groupby, at least one column must be selected.")
 
-        available_columns = {c.get_name() for c in self.__base_frame.columns()}
-        missing_cols = [col for col in columns_to_select if col not in available_columns]
+        selected_columns: PyLegendList[TdsColumn] = [
+            col for col in self.__base_frame.columns() if col.get_name() in columns_to_select]
 
-        if len(missing_cols) > 0:
+        if len(selected_columns) < len(columns_to_select):
+            available_columns = {c.get_name() for c in self.__base_frame.columns()}
+            missing_cols = [col for col in columns_to_select if col not in available_columns]
             raise KeyError(
                 f"Column(s) {missing_cols} selected after groupby do not exist in the current frame. "
                 f"Current frame columns: {sorted(available_columns)}"
@@ -163,16 +194,47 @@ class PandasApiGroupbyTdsFrame:
             dropna=self.__dropna,
         )
 
-        new_frame.__selected_columns = columns_to_select.copy()
+        new_frame.__selected_columns = selected_columns
+
+        if selected_columns is not None and isinstance(item, str):
+            column: TdsColumn = selected_columns[0]
+            col_type = column.get_type()
+            if col_type == "Boolean":  # pragma: no cover (Boolean column not supported in PURE)
+                from pylegend.core.language.pandas_api.pandas_api_groupby_series import BooleanGroupbySeries
+                return BooleanGroupbySeries(new_frame)
+            elif col_type == "String":
+                from pylegend.core.language.pandas_api.pandas_api_groupby_series import StringGroupbySeries
+                return StringGroupbySeries(new_frame)
+            elif col_type == "Number":
+                from pylegend.core.language.pandas_api.pandas_api_groupby_series import NumberGroupbySeries
+                return NumberGroupbySeries(new_frame)
+            elif col_type == "Integer":
+                from pylegend.core.language.pandas_api.pandas_api_groupby_series import IntegerGroupbySeries
+                return IntegerGroupbySeries(new_frame)
+            elif col_type == "Float":
+                from pylegend.core.language.pandas_api.pandas_api_groupby_series import FloatGroupbySeries
+                return FloatGroupbySeries(new_frame)
+            elif col_type == "Date":
+                from pylegend.core.language.pandas_api.pandas_api_groupby_series import DateGroupbySeries
+                return DateGroupbySeries(new_frame)
+            elif col_type == "DateTime":
+                from pylegend.core.language.pandas_api.pandas_api_groupby_series import DateTimeGroupbySeries
+                return DateTimeGroupbySeries(new_frame)
+            elif col_type == "StrictDate":
+                from pylegend.core.language.pandas_api.pandas_api_groupby_series import StrictDateGroupbySeries
+                return StrictDateGroupbySeries(new_frame)
+            else:
+                raise ValueError(f"Unsupported column type '{col_type}' for column '{column.get_name()}'")  # pragma: no cover
+
         return new_frame
 
     def base_frame(self) -> PandasApiBaseTdsFrame:
         return self.__base_frame
 
-    def grouping_column_name_list(self) -> PyLegendList[str]:
-        return self.__grouping_column_name_list.copy()
+    def get_grouping_columns(self) -> PyLegendList[TdsColumn]:
+        return self.__grouping_columns.copy()
 
-    def selected_columns(self) -> PyLegendOptional[PyLegendList[str]]:
+    def get_selected_columns(self) -> PyLegendOptional[PyLegendList[TdsColumn]]:
         if self.__selected_columns is None:
             return None
         return self.__selected_columns.copy()
@@ -197,7 +259,7 @@ class PandasApiGroupbyTdsFrame:
             aggregated_result = PandasApiAppliedFunctionTdsFrame(
                 SortValuesFunction(
                     base_frame=aggregated_result,
-                    by=self.grouping_column_name_list(),
+                    by=[col.get_name() for col in self.get_grouping_columns()],
                     axis=0,
                     ascending=True,
                     inplace=False,
@@ -217,10 +279,8 @@ class PandasApiGroupbyTdsFrame:
         *args: PyLegendPrimitiveOrPythonPrimitive,
         **kwargs: PyLegendPrimitiveOrPythonPrimitive,
     ) -> "PandasApiTdsFrame":
-        from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import PandasApiAppliedFunctionTdsFrame
-        from pylegend.core.tds.pandas_api.frames.functions.aggregate_function import AggregateFunction
 
-        return PandasApiAppliedFunctionTdsFrame(AggregateFunction(self, func, axis, *args, **kwargs))
+        return self.aggregate(func, axis, *args, **kwargs)
 
     def sum(
         self,

{pylegend-0.13.0.dist-info → pylegend-0.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pylegend
-Version: 0.13.0
+Version: 0.14.0
 Summary: Python language binding for Legend data management platform
 License: Apache-2.0
 License-File: LICENSE

{pylegend-0.13.0.dist-info → pylegend-0.14.0.dist-info}/RECORD

@@ -16,7 +16,8 @@ pylegend/core/language/legendql_api/legendql_api_tds_row.py,sha256=5hejBF2uYjXua
 pylegend/core/language/pandas_api/__init__.py,sha256=g6w4WCuQ2pqQG6yyn-QLLXED3ttOOB8YnXzVt3ijb28,578
 pylegend/core/language/pandas_api/pandas_api_aggregate_specification.py,sha256=T_RaPB9y_7kcnMC_CIEDJhxORID1plR99IGGPZvDnBk,1474
 pylegend/core/language/pandas_api/pandas_api_custom_expressions.py,sha256=xOXp0NdyNW6j_R_1sCy1JcdN9EWIqYRXngocsINpllE,2590
-pylegend/core/language/pandas_api/pandas_api_series.py,sha256=WJ--FaWeODIvS26RErugschR_CmypjzVu6H64sfwokQ,7359
+pylegend/core/language/pandas_api/pandas_api_groupby_series.py,sha256=MU6o_e2NIwo2OZHcXS8zuxZa14QG5SygXjnhHRy8H-4,16200
+pylegend/core/language/pandas_api/pandas_api_series.py,sha256=Jock_ZYikBBCr-bVHpYEcoKV7bg0hdzQV4KJU99Z0O4,16452
 pylegend/core/language/pandas_api/pandas_api_tds_row.py,sha256=L0O5BLok3KqmzUgXFfM2fQgrpAxCfQ74bOplnetjyvw,2516
 pylegend/core/language/shared/__init__.py,sha256=g6w4WCuQ2pqQG6yyn-QLLXED3ttOOB8YnXzVt3ijb28,578
 pylegend/core/language/shared/column_expressions.py,sha256=qWHVvwPGwKroQX94a_ovUrxCPnosVMX3tBWlTj7uJ6k,4333
@@ -112,7 +113,7 @@ pylegend/core/tds/legendql_api/frames/legendql_api_tds_frame.py,sha256=BFDdgeZ66
 pylegend/core/tds/pandas_api/__init__.py,sha256=LXTDJSDmHQXtnMDZouhZp9IZQVpY6ONkINbUYjtnMkE,578
 pylegend/core/tds/pandas_api/frames/__init__.py,sha256=LXTDJSDmHQXtnMDZouhZp9IZQVpY6ONkINbUYjtnMkE,578
 pylegend/core/tds/pandas_api/frames/functions/__init__.py,sha256=LXTDJSDmHQXtnMDZouhZp9IZQVpY6ONkINbUYjtnMkE,578
-pylegend/core/tds/pandas_api/frames/functions/aggregate_function.py,sha256=rpFjIOE9LmbfL78b3fiD2dRB0Dq0hqGmdQLHcsvi59Y,21110
+pylegend/core/tds/pandas_api/frames/functions/aggregate_function.py,sha256=L-re1fgm1VPgy2VeY0BoXIDEhpfciWV-pgDK164HVFI,21646
 pylegend/core/tds/pandas_api/frames/functions/assign_function.py,sha256=uhCv1sDnVBZmT3H5Alu2NUvek8aKqWz5HIG2Vtut-hs,6931
 pylegend/core/tds/pandas_api/frames/functions/drop.py,sha256=tJMeL9Or43QDng9SsxYvW_yus3Hjp03PSlX7P857d7s,7269
 pylegend/core/tds/pandas_api/frames/functions/dropna.py,sha256=OVVwUsPSAykm1g-afVvwxQCr_AaoQtH0cFRVffl9eHs,6161
@@ -125,9 +126,9 @@ pylegend/core/tds/pandas_api/frames/functions/merge.py,sha256=bp9a9reNtUAKqaz1Kf
 pylegend/core/tds/pandas_api/frames/functions/rename.py,sha256=afXj8EhsTVUNJAZDFAM_K3VOX5oH3TA2FxSDoZHfT6M,8898
 pylegend/core/tds/pandas_api/frames/functions/sort_values_function.py,sha256=sppDTCW3X0RXLYD2zBvjKEObtc_JfEtoNY7lj-60zqQ,7132
 pylegend/core/tds/pandas_api/frames/functions/truncate_function.py,sha256=VUr9jzVhnU_mJVootUQfcEG8Q66vSJba1QGUGQiYxCk,6214
-pylegend/core/tds/pandas_api/frames/pandas_api_applied_function_tds_frame.py,sha256=u2ONcOw9kP1JJxl2VZH_fKIaqdyY0n9nuIy_p-yQ93g,2967
-pylegend/core/tds/pandas_api/frames/pandas_api_base_tds_frame.py,sha256=TnbFtyKwMK261MfWPVC591X4m1xu37xLOd68tvcHnwI,38820
-pylegend/core/tds/pandas_api/frames/pandas_api_groupby_tds_frame.py,sha256=0K4Hb3FPs7ZzlZCWFG-65ZKkqEvHHj_FvE26g9rz7ps,13714
+pylegend/core/tds/pandas_api/frames/pandas_api_applied_function_tds_frame.py,sha256=3BcR2OH5uGvKIep6P1hrgK8QoT5RCzZeh9KfBx1TmgU,3071
+pylegend/core/tds/pandas_api/frames/pandas_api_base_tds_frame.py,sha256=eK-goe9LdQJQLwdlfAllQ0kE8OCUECO9qRzyYnPQNZw,39017
+pylegend/core/tds/pandas_api/frames/pandas_api_groupby_tds_frame.py,sha256=YEtrE07ynHzGBJpSa7FhCQ2834NrOjPkECowfCPFJrQ,16820
 pylegend/core/tds/pandas_api/frames/pandas_api_input_tds_frame.py,sha256=FgwIJCkawXuIjXYfVVrLa5RHfOO5xnSFI0pXti34L_8,2116
 pylegend/core/tds/pandas_api/frames/pandas_api_tds_frame.py,sha256=vPPtO_zvElaZfa4kgUEOIMnBMe133TNqTGE2DDDyC3M,12233
 pylegend/core/tds/result_handler/__init__.py,sha256=8RE84xfkARwDbaQCvZulXcvDJlI-V5DuJp9RsdaGnqU,1141
@@ -171,9 +172,9 @@ pylegend/legacy_api_tds_client.py,sha256=IXfo2pdBFV3M3S4RYKJcvudMc_OGdR0yvJhTV-o
 pylegend/legendql_api_tds_client.py,sha256=oS6NET5pAA-hfVhVvwG6sRF7omyBs_gEYSAgA8Tky8U,2357
 pylegend/utils/__init__.py,sha256=LXTDJSDmHQXtnMDZouhZp9IZQVpY6ONkINbUYjtnMkE,578
 pylegend/utils/class_utils.py,sha256=t4PpF3jAXS_D6p9TqlSppryNYNOuy5C-kbKn2Kgb4QU,973
-pylegend-0.13.0.dist-info/METADATA,sha256=AbsE8ssm_7IVkGAoMIkAEv7yHKYsQvNqjnGEy30z7xU,4281
-pylegend-0.13.0.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
-pylegend-0.13.0.dist-info/licenses/LICENSE,sha256=AGR96_qQPZO66Gjqq4G6r_g670K35VtW-IobTAkmZJM,11343
-pylegend-0.13.0.dist-info/licenses/LICENSE.spdx,sha256=i7TsBclLotUvMjx9vZ_6S8Pp0r4uknWGw1RwiKBBvQ4,207
-pylegend-0.13.0.dist-info/licenses/NOTICE,sha256=2Lr4FqiscyRI7-vyn7c2z-zqUw2p6x7upJyBvFKkHjk,167
-pylegend-0.13.0.dist-info/RECORD,,
+pylegend-0.14.0.dist-info/METADATA,sha256=9onT96z16Z8t06EPg1At-Zqd31fTSiuFUEt9GVgEQkc,4281
+pylegend-0.14.0.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+pylegend-0.14.0.dist-info/licenses/LICENSE,sha256=AGR96_qQPZO66Gjqq4G6r_g670K35VtW-IobTAkmZJM,11343
+pylegend-0.14.0.dist-info/licenses/LICENSE.spdx,sha256=i7TsBclLotUvMjx9vZ_6S8Pp0r4uknWGw1RwiKBBvQ4,207
+pylegend-0.14.0.dist-info/licenses/NOTICE,sha256=2Lr4FqiscyRI7-vyn7c2z-zqUw2p6x7upJyBvFKkHjk,167
+pylegend-0.14.0.dist-info/RECORD,,

{pylegend-0.13.0.dist-info → pylegend-0.14.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.3.0
+Generator: poetry-core 2.3.1
 Root-Is-Purelib: true
 Tag: py3-none-any