pylegend 0.11.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

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

@@ -12,15 +12,24 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import copy
 from abc import ABCMeta, abstractmethod
 from datetime import date, datetime
 from typing import TYPE_CHECKING
 
+from typing_extensions import Concatenate
+
+try:
+    from typing import ParamSpec
+except Exception:
+    from typing_extensions import ParamSpec  # type: ignore
+
 import pandas as pd
 
 from pylegend._typing import (
     PyLegendSequence,
     PyLegendTypeVar,
+    PyLegendType,
     PyLegendList,
     PyLegendTuple,
     PyLegendSet,
@@ -33,7 +42,11 @@ from pylegend.core.database.sql_to_string import (
     SqlToStringConfig,
     SqlToStringFormat
 )
-from pylegend.core.language import PyLegendPrimitive, PyLegendInteger, PyLegendBoolean
+from pylegend.core.language import (
+    PyLegendPrimitive,
+    PyLegendInteger,
+    PyLegendBoolean,
+)
 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.primitives.primitive import PyLegendPrimitiveOrPythonPrimitive
@@ -47,7 +60,7 @@ from pylegend.core.tds.result_handler import (
 )
 from pylegend.core.tds.tds_column import TdsColumn
 from pylegend.core.tds.tds_frame import FrameToPureConfig
-from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.core.tds.tds_frame import FrameToSqlConfig, PyLegendTdsFrame
 from pylegend.extensions.tds.result_handler import (
     ToPandasDfResultHandler,
     PandasDfReadConfig,
@@ -62,6 +75,7 @@ __all__: PyLegendSequence[str] = [
 ]
 
 R = PyLegendTypeVar('R')
+P = ParamSpec("P")
 
 
 class PandasApiBaseTdsFrame(PandasApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
@@ -73,9 +87,12 @@ class PandasApiBaseTdsFrame(PandasApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
             cols = "[" + ", ".join([str(c) for c in columns]) + "]"
             raise ValueError(f"TdsFrame cannot have duplicated column names. Passed columns: {cols}")
         self.__columns = [c.copy() for c in columns]
+        self._transformed_frame = None
 
     def columns(self) -> PyLegendSequence[TdsColumn]:
-        return [c.copy() for c in self.__columns]
+        if self._transformed_frame is None:
+            return [c.copy() for c in self.__columns]
+        return self._transformed_frame.columns()
 
     def __getitem__(
             self,
@@ -97,7 +114,8 @@ class PandasApiBaseTdsFrame(PandasApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
                 if col.get_name() == key:
                     col_type = col.get_type()
                     if col_type == "Boolean":
-                        from pylegend.core.language.pandas_api.pandas_api_series import BooleanSeries  # pragma: no cover
+                        from pylegend.core.language.pandas_api.pandas_api_series import \
+                            BooleanSeries  # pragma: no cover
                         return BooleanSeries(self, key)  # pragma: no cover (Boolean column not supported in PURE)
                     elif col_type == "String":
                         from pylegend.core.language.pandas_api.pandas_api_series import StringSeries
@@ -130,6 +148,41 @@ class PandasApiBaseTdsFrame(PandasApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
         else:
             raise TypeError(f"Invalid key type: {type(key)}. Expected str, list, or boolean expression")
 
+    def __setitem__(self, key: str, value: PyLegendUnion["Series", PyLegendPrimitiveOrPythonPrimitive]) -> None:
+        """
+        Pandas-like column assignment with replace semantics:
+        - If column exists, drop it first.
+        - Then assign the new value (Series or constant).
+        """
+        from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import (
+            PandasApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.pandas_api.frames.functions.assign_function import AssignFunction
+        from pylegend.core.language.pandas_api.pandas_api_series import Series
+
+        # Type Check
+        if not isinstance(key, str):
+            raise TypeError(f"Column name must be a string, got: {type(key)}")
+
+        # Reject cross-frame assignment
+        if isinstance(value, Series):
+            origin = value.get_base_frame()
+            if origin is not None and origin is not self:
+                raise ValueError("Assignment from a different frame is not allowed")
+
+        # Normalize the assignment value
+        col_def = {}
+        if callable(value):
+            col_def[key] = value
+        else:
+            col_def[key] = lambda row: value
+
+        working_frame = copy.deepcopy(self)
+        assign_applied = PandasApiAppliedFunctionTdsFrame(AssignFunction(working_frame, col_definitions=col_def))
+
+        self._transformed_frame = assign_applied  # type: ignore
+        self.__columns = assign_applied.columns()
+
     def assign(
             self,
             **kwargs: PyLegendCallable[
@@ -217,7 +270,7 @@ class PandasApiBaseTdsFrame(PandasApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
             index: PyLegendOptional[PyLegendUnion[str, PyLegendSequence[str], PyLegendSet[str]]] = None,
             columns: PyLegendOptional[PyLegendUnion[str, PyLegendSequence[str], PyLegendSet[str]]] = None,
             level: PyLegendOptional[PyLegendUnion[int, PyLegendInteger, str]] = None,
-            inplace: PyLegendUnion[bool, PyLegendBoolean] = True,
+            inplace: PyLegendUnion[bool, PyLegendBoolean] = False,
             errors: str = "raise",
     ) -> "PandasApiTdsFrame":
         from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import \
@@ -238,11 +291,11 @@ class PandasApiBaseTdsFrame(PandasApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
         )
 
     def aggregate(
-        self,
-        func: PyLegendAggInput,
-        axis: PyLegendUnion[int, str] = 0,
-        *args: PyLegendPrimitiveOrPythonPrimitive,
-        **kwargs: PyLegendPrimitiveOrPythonPrimitive
+            self,
+            func: PyLegendAggInput,
+            axis: PyLegendUnion[int, str] = 0,
+            *args: PyLegendPrimitiveOrPythonPrimitive,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
     ) -> "PandasApiTdsFrame":
         from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import (
             PandasApiAppliedFunctionTdsFrame
@@ -257,11 +310,11 @@ class PandasApiBaseTdsFrame(PandasApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
         ))
 
     def agg(
-        self,
-        func: PyLegendAggInput,
-        axis: PyLegendUnion[int, str] = 0,
-        *args: PyLegendPrimitiveOrPythonPrimitive,
-        **kwargs: PyLegendPrimitiveOrPythonPrimitive
+            self,
+            func: PyLegendAggInput,
+            axis: PyLegendUnion[int, str] = 0,
+            *args: PyLegendPrimitiveOrPythonPrimitive,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
     ) -> "PandasApiTdsFrame":
         from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import (
             PandasApiAppliedFunctionTdsFrame
@@ -293,7 +346,8 @@ class PandasApiBaseTdsFrame(PandasApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
         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())}")
+            raise NotImplementedError(
+                f"Additional keyword arguments not supported in sum function: {list(kwargs.keys())}")
         return self.aggregate("sum", 0)
 
     def mean(
@@ -310,7 +364,8 @@ class PandasApiBaseTdsFrame(PandasApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
         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())}")
+            raise NotImplementedError(
+                f"Additional keyword arguments not supported in mean function: {list(kwargs.keys())}")
         return self.aggregate("mean", 0)
 
     def min(
@@ -327,7 +382,8 @@ class PandasApiBaseTdsFrame(PandasApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
         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())}")
+            raise NotImplementedError(
+                f"Additional keyword arguments not supported in min function: {list(kwargs.keys())}")
         return self.aggregate("min", 0)
 
     def max(
@@ -344,7 +400,8 @@ class PandasApiBaseTdsFrame(PandasApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
         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())}")
+            raise NotImplementedError(
+                f"Additional keyword arguments not supported in max function: {list(kwargs.keys())}")
         return self.aggregate("max", 0)
 
     def std(
@@ -360,11 +417,13 @@ class PandasApiBaseTdsFrame(PandasApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
         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}")
+            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())}")
+            raise NotImplementedError(
+                f"Additional keyword arguments not supported in std function: {list(kwargs.keys())}")
         return self.aggregate("std", 0)
 
     def var(
@@ -384,7 +443,8 @@ class PandasApiBaseTdsFrame(PandasApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
         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())}")
+            raise NotImplementedError(
+                f"Additional keyword arguments not supported in var function: {list(kwargs.keys())}")
         return self.aggregate("var", 0)
 
     def count(
@@ -398,18 +458,19 @@ class PandasApiBaseTdsFrame(PandasApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
         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())}")
+            raise NotImplementedError(
+                f"Additional keyword arguments not supported in count function: {list(kwargs.keys())}")
         return self.aggregate("count", 0)
 
     def groupby(
-        self,
-        by: PyLegendUnion[str, PyLegendList[str]],
-        level: PyLegendOptional[PyLegendUnion[str, int, PyLegendList[str]]] = None,
-        as_index: bool = False,
-        sort: bool = True,
-        group_keys: bool = False,
-        observed: bool = False,
-        dropna: bool = False,
+            self,
+            by: PyLegendUnion[str, PyLegendList[str]],
+            level: PyLegendOptional[PyLegendUnion[str, int, PyLegendList[str]]] = None,
+            as_index: bool = False,
+            sort: bool = True,
+            group_keys: bool = False,
+            observed: bool = False,
+            dropna: bool = False,
     ) -> "PandasApiGroupbyTdsFrame":
         from pylegend.core.tds.pandas_api.frames.pandas_api_groupby_tds_frame import (
             PandasApiGroupbyTdsFrame
@@ -547,13 +608,218 @@ class PandasApiBaseTdsFrame(PandasApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
             )
         )
 
+    def apply(
+            self,
+            func: PyLegendUnion[
+                PyLegendCallable[Concatenate["Series", P], PyLegendPrimitiveOrPythonPrimitive],
+                str
+            ],
+            axis: PyLegendUnion[int, str] = 0,
+            raw: bool = False,
+            result_type: PyLegendOptional[str] = None,
+            args: PyLegendTuple[PyLegendPrimitiveOrPythonPrimitive, ...] = (),
+            by_row: PyLegendUnion[bool, str] = "compat",
+            engine: str = "python",
+            engine_kwargs: PyLegendOptional[PyLegendDict[str, PyLegendPrimitiveOrPythonPrimitive]] = None,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        """
+        Pandas-like apply (columns-only):
+        - Supports callable func applied to each column (axis=0 or 'index')
+        - Internally delegates to assign by constructing lambdas per column
+        - Unsupported params raise NotImplementedError
+        """
+
+        from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import (
+            PandasApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.pandas_api.frames.functions.assign_function import AssignFunction
+        from pylegend.core.language.pandas_api.pandas_api_series import Series
+
+        # Validation
+        if axis not in (0, "index"):
+            raise ValueError("Only column-wise apply is supported. Use axis=0 or 'index'")
+        if raw:
+            raise NotImplementedError("raw=True is not supported. Use raw=False")
+        if result_type is not None:
+            raise NotImplementedError("result_type is not supported")
+        if by_row not in (False, "compat"):
+            raise NotImplementedError("by_row must be False or 'compat'")
+        if engine != "python":
+            raise NotImplementedError("Only engine='python' is supported")
+        if engine_kwargs is not None:
+            raise NotImplementedError("engine_kwargs are not supported")
+        if isinstance(func, str):
+            raise NotImplementedError("String-based apply is not supported")
+        if not callable(func):
+            raise TypeError("Function must be a callable")
+
+        # Build assign column definitions: apply func to each column Series
+        col_definitions = {}
+        for c in self.columns():
+            col_name = c.get_name()
+            series = self[col_name]
+
+            # Compute row callable via func on the Series
+            def _row_callable(
+                    _row: PandasApiTdsRow,
+                    _s: Series = series,  # type: ignore
+                    _a: PyLegendTuple[PyLegendPrimitiveOrPythonPrimitive, ...] = args,
+                    _k: PyLegendPrimitiveOrPythonPrimitive = kwargs  # type: ignore
+            ) -> PyLegendPrimitiveOrPythonPrimitive:
+                return func(_s, *_a, **_k)  # type: ignore
+
+            col_definitions[col_name] = _row_callable
+
+        return PandasApiAppliedFunctionTdsFrame(
+            AssignFunction(self, col_definitions=col_definitions)  # type: ignore
+        )
+
+    def head(self, n: int = 5) -> "PandasApiTdsFrame":
+        """
+        Return the first `n` rows by calling truncate on rows.
+        Negative `n` is not supported.
+        """
+        if not isinstance(n, int):
+            raise TypeError(f"n must be an int, got {type(n)}")
+        if n < 0:
+            raise NotImplementedError("Negative n is not supported yet in Pandas API head")
+
+        return self.truncate(before=None, after=max(n - 1, -1), axis=0, copy=True)
+
+    @property
+    def shape(self) -> PyLegendTuple[int, int]:
+        """
+        Return a tuple representing the dimensionality of the TdsFrame
+        as (number of rows, number of columns).
+        """
+
+        col_name = self.columns()[0].get_name()
+        newframe = self.aggregate(func={col_name: "count"}, axis=0)
+
+        df = newframe.execute_frame_to_pandas_df()
+
+        total_rows = df.iloc[0, 0]
+        total_cols = len(self.columns())
+
+        return (total_rows, total_cols)  # type: ignore
+
+    def dropna(
+            self,
+            axis: PyLegendUnion[int, str] = 0,
+            how: str = "any",
+            thresh: PyLegendOptional[int] = None,
+            subset: PyLegendOptional[PyLegendUnion[str, PyLegendSequence[str]]] = None,
+            inplace: bool = False,
+            ignore_index: bool = False
+    ) -> "PandasApiTdsFrame":
+        """
+        Remove missing values.
+
+        Parameters
+        ----------
+        axis : {0 or 'index'}, default 0
+            Determine if rows or columns which contain missing values are removed.
+            * 0, or 'index' : Drop rows which contain missing values.
+            Currently, only `axis=0` is supported.
+        how : {'any', 'all'}, default 'any'
+            Determine if row is removed from TdsFrame, when we have at least one NA or all NA.
+            * 'any' : If any NA values are present, drop that row.
+            * 'all' : If all values are NA, drop that row.
+        thresh : int, optional
+            Not implemented yet.
+        subset : list-like, optional
+            Labels along other axis to consider, e.g. if you are dropping rows
+            these would be a list of columns to include.
+        inplace : bool, default False
+            Not implemented yet.
+        ignore_index : bool, default False
+            Not implemented yet.
+
+        Returns
+        -------
+        PandasApiTdsFrame
+            TdsFrame with NA entries dropped.
+        """
+        from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import (
+            PandasApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.pandas_api.frames.functions.dropna import PandasApiDropnaFunction
+        return PandasApiAppliedFunctionTdsFrame(
+            PandasApiDropnaFunction(
+                base_frame=self,
+                axis=axis,
+                how=how,
+                thresh=thresh,
+                subset=subset,
+                inplace=inplace,
+                ignore_index=ignore_index
+            )
+        )
+
+    def fillna(
+            self,
+            value: PyLegendUnion[
+                int, float, str, bool, date, datetime,
+                PyLegendDict[str, PyLegendUnion[int, float, str, bool, date, datetime]]
+            ] = None,  # type: ignore
+            axis: PyLegendOptional[PyLegendUnion[int, str]] = 0,
+            inplace: bool = False,
+            limit: PyLegendOptional[int] = None
+    ) -> "PandasApiTdsFrame":
+        """
+        Fill missing values.
+
+        Parameters
+        ----------
+        base_frame : PandasApiBaseTdsFrame
+            The base frame to apply fillna on.
+        value : scalar, dict, default None
+            Value to use to fill holes (e.g. 0), alternately a dict of values specifying
+            which value to use for each column of TdsFrame.
+        axis : {0 or 'index'}, default 0
+            Axis along which to fill missing values.
+            * 0, or 'index' : Fill missing values for each column.
+            Currently, only `axis=0` is supported.
+        inplace : bool, default False
+            Not implemented yet.
+        limit : int, optional
+            Not implemented yet.
+
+        Returns
+        -------
+        PandasApiTdsFrame
+            TdsFrame with NA entries filled.
+        """
+        from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import (
+            PandasApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.pandas_api.frames.functions.fillna import PandasApiFillnaFunction
+        return PandasApiAppliedFunctionTdsFrame(
+            PandasApiFillnaFunction(
+                base_frame=self,
+                value=value,
+                axis=axis,
+                inplace=inplace,
+                limit=limit
+            )
+        )
+
     @abstractmethod
-    def to_sql_query_object(self, config: FrameToSqlConfig) -> QuerySpecification:
+    def get_super_type(self) -> PyLegendType[PyLegendTdsFrame]:
         pass  # pragma: no cover
 
-    @abstractmethod
+    def to_sql_query_object(self, config: FrameToSqlConfig) -> QuerySpecification:
+        if self._transformed_frame is None:
+            return self.get_super_type().to_sql_query_object(self, config)  # type: ignore
+        else:
+            return self._transformed_frame.to_sql_query_object(config)
+
     def to_pure(self, config: FrameToPureConfig) -> str:
-        pass  # pragma: no cover
+        if self._transformed_frame is None:
+            return self.get_super_type().to_pure(self, config)  # type: ignore
+        else:
+            return self._transformed_frame.to_pure(config)
 
     def to_pure_query(self, config: FrameToPureConfig = FrameToPureConfig()) -> str:
         return self.to_pure(config)

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

@@ -16,6 +16,13 @@ from abc import abstractmethod
 from datetime import date, datetime
 from typing import TYPE_CHECKING
 
+from typing_extensions import Concatenate
+
+try:
+    from typing import ParamSpec
+except Exception:
+    from typing_extensions import ParamSpec  # type: ignore
+
 from pylegend._typing import (
     PyLegendCallable,
     PyLegendSequence,
@@ -45,6 +52,8 @@ __all__: PyLegendSequence[str] = [
     "PandasApiTdsFrame"
 ]
 
+P = ParamSpec("P")
+
 
 class PandasApiTdsFrame(PyLegendTdsFrame):
 
@@ -55,6 +64,14 @@ class PandasApiTdsFrame(PyLegendTdsFrame):
     ) -> PyLegendUnion["PandasApiTdsFrame", "Series"]:
         pass  # pragma: no cover
 
+    @abstractmethod
+    def __setitem__(
+            self,
+            key: str,
+            value: PyLegendUnion["Series", PyLegendPrimitiveOrPythonPrimitive]
+    ) -> None:
+        pass  # pragma: no cover
+
     @abstractmethod
     def assign(
             self,
@@ -107,7 +124,7 @@ class PandasApiTdsFrame(PyLegendTdsFrame):
             index: PyLegendOptional[PyLegendUnion[str, PyLegendSequence[str], PyLegendSet[str]]] = None,
             columns: PyLegendOptional[PyLegendUnion[str, PyLegendSequence[str], PyLegendSet[str]]] = None,
             level: PyLegendOptional[PyLegendUnion[int, PyLegendInteger, str]] = None,
-            inplace: PyLegendUnion[bool, PyLegendBoolean] = True,
+            inplace: PyLegendUnion[bool, PyLegendBoolean] = False,
             errors: str = "raise",
     ) -> "PandasApiTdsFrame":
         pass  # pragma: no cover
@@ -183,14 +200,14 @@ class PandasApiTdsFrame(PyLegendTdsFrame):
 
     @abstractmethod
     def groupby(
-        self,
-        by: PyLegendUnion[str, PyLegendList[str]],
-        level: PyLegendOptional[PyLegendUnion[str, int, PyLegendList[str]]] = None,
-        as_index: bool = False,
-        sort: bool = True,
-        group_keys: bool = False,
-        observed: bool = False,
-        dropna: bool = False,
+            self,
+            by: PyLegendUnion[str, PyLegendList[str]],
+            level: PyLegendOptional[PyLegendUnion[str, int, PyLegendList[str]]] = None,
+            as_index: bool = False,
+            sort: bool = True,
+            group_keys: bool = False,
+            observed: bool = False,
+            dropna: bool = False,
     ) -> "PandasApiGroupbyTdsFrame":
         pass  # pragma: no cover
 
@@ -265,3 +282,55 @@ class PandasApiTdsFrame(PyLegendTdsFrame):
             **kwargs: PyLegendPrimitiveOrPythonPrimitive
     ) -> "PandasApiTdsFrame":
         pass  # pragma: no cover
+
+    @abstractmethod
+    def apply(
+            self,
+            func: PyLegendUnion[
+                PyLegendCallable[Concatenate["Series", P], PyLegendPrimitiveOrPythonPrimitive],
+                str
+            ],
+            axis: PyLegendUnion[int, str] = 0,
+            raw: bool = False,
+            result_type: PyLegendOptional[str] = None,
+            args: PyLegendTuple[PyLegendPrimitiveOrPythonPrimitive, ...] = (),
+            by_row: PyLegendUnion[bool, str] = "compat",
+            engine: str = "python",
+            engine_kwargs: PyLegendOptional[PyLegendDict[str, PyLegendPrimitiveOrPythonPrimitive]] = None,
+            **kwargs: PyLegendPrimitiveOrPythonPrimitive
+    ) -> "PandasApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def head(self, n: int = 5) -> "PandasApiTdsFrame":
+        pass  # pragma: no cover
+
+    @property
+    @abstractmethod
+    def shape(self) -> PyLegendTuple[int, int]:
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def dropna(
+            self,
+            axis: PyLegendUnion[int, str] = 0,
+            how: str = "any",
+            thresh: PyLegendOptional[int] = None,
+            subset: PyLegendOptional[PyLegendUnion[str, PyLegendSequence[str]]] = None,
+            inplace: bool = False,
+            ignore_index: bool = False
+    ) -> "PandasApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def fillna(
+            self,
+            value: PyLegendUnion[
+                int, float, str, bool, date, datetime,
+                PyLegendDict[str, PyLegendUnion[int, float, str, bool, date, datetime]]
+            ] = None,  # type: ignore
+            axis: PyLegendOptional[PyLegendUnion[int, str]] = 0,
+            inplace: bool = False,
+            limit: PyLegendOptional[int] = None
+    ) -> "PandasApiTdsFrame":
+        pass  # pragma: no cover

pylegend/extensions/tds/pandas_api/frames/pandas_api_legend_function_input_frame.py

@@ -13,20 +13,21 @@
 # limitations under the License.
 
 from pylegend._typing import (
-    PyLegendSequence
+    PyLegendSequence,
+    PyLegendType
 )
-from pylegend.core.tds.pandas_api.frames.pandas_api_input_tds_frame import PandasApiExecutableInputTdsFrame
 from pylegend.core.project_cooridnates import ProjectCoordinates
 from pylegend.core.request.legend_client import LegendClient
+from pylegend.core.tds.pandas_api.frames.pandas_api_input_tds_frame import PandasApiExecutableInputTdsFrame
+from pylegend.core.tds.tds_frame import PyLegendTdsFrame
 from pylegend.extensions.tds.abstract.legend_function_input_frame import LegendFunctionInputFrameAbstract
 
-
 __all__: PyLegendSequence[str] = [
     "PandasApiLegendFunctionInputFrame"
 ]
 
 
-class PandasApiLegendFunctionInputFrame(LegendFunctionInputFrameAbstract, PandasApiExecutableInputTdsFrame):
+class PandasApiLegendFunctionInputFrame(PandasApiExecutableInputTdsFrame, LegendFunctionInputFrameAbstract):
 
     def __init__(
             self,
@@ -35,6 +36,7 @@ class PandasApiLegendFunctionInputFrame(LegendFunctionInputFrameAbstract, Pandas
             legend_client: LegendClient,
     ) -> None:
         LegendFunctionInputFrameAbstract.__init__(self, path=path, project_coordinates=project_coordinates)
+        self._transformed_frame = None
         PandasApiExecutableInputTdsFrame.__init__(
             self,
             legend_client=legend_client,
@@ -44,3 +46,6 @@ class PandasApiLegendFunctionInputFrame(LegendFunctionInputFrameAbstract, Pandas
 
     def __str__(self) -> str:
         return f"PandasApiLegendFunctionInputFrame({'.'.join(self.get_path())})"
+
+    def get_super_type(self) -> PyLegendType[PyLegendTdsFrame]:
+        return LegendFunctionInputFrameAbstract

pylegend/extensions/tds/pandas_api/frames/pandas_api_legend_service_input_frame.py

@@ -13,20 +13,23 @@
 # limitations under the License.
 
 from pylegend._typing import (
-    PyLegendSequence
+    PyLegendSequence,
+    PyLegendType
 )
-from pylegend.core.tds.pandas_api.frames.pandas_api_input_tds_frame import PandasApiExecutableInputTdsFrame
 from pylegend.core.project_cooridnates import ProjectCoordinates
 from pylegend.core.request.legend_client import LegendClient
+from pylegend.core.tds.pandas_api.frames.pandas_api_input_tds_frame import PandasApiExecutableInputTdsFrame
+from pylegend.core.tds.tds_frame import (
+    PyLegendTdsFrame
+)
 from pylegend.extensions.tds.abstract.legend_service_input_frame import LegendServiceInputFrameAbstract
 
-
 __all__: PyLegendSequence[str] = [
     "PandasApiLegendServiceInputFrame"
 ]
 
 
-class PandasApiLegendServiceInputFrame(LegendServiceInputFrameAbstract, PandasApiExecutableInputTdsFrame):
+class PandasApiLegendServiceInputFrame(PandasApiExecutableInputTdsFrame, LegendServiceInputFrameAbstract):
 
     def __init__(
             self,
@@ -35,6 +38,7 @@ class PandasApiLegendServiceInputFrame(LegendServiceInputFrameAbstract, PandasAp
             legend_client: LegendClient,
     ) -> None:
         LegendServiceInputFrameAbstract.__init__(self, pattern=pattern, project_coordinates=project_coordinates)
+        self._transformed_frame = None
         PandasApiExecutableInputTdsFrame.__init__(
             self,
             legend_client=legend_client,
@@ -43,4 +47,7 @@ class PandasApiLegendServiceInputFrame(LegendServiceInputFrameAbstract, PandasAp
         LegendServiceInputFrameAbstract.set_initialized(self, True)
 
     def __str__(self) -> str:
-        return f"PandasApiLegendServiceInputFrame({'.'.join(self.get_pattern())})"
+        return f"PandasApiLegendServiceInputFrame({'.'.join(self.get_pattern())})"  # pragma: no cover
+
+    def get_super_type(self) -> PyLegendType[PyLegendTdsFrame]:
+        return LegendServiceInputFrameAbstract