pylegend 0.11.0__py3-none-any.whl → 0.13.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,
@@ -56,12 +69,15 @@ from pylegend.extensions.tds.result_handler import (
 if TYPE_CHECKING:
     from pylegend.core.language.pandas_api.pandas_api_series import Series
     from pylegend.core.tds.pandas_api.frames.pandas_api_groupby_tds_frame import PandasApiGroupbyTdsFrame
+    from pylegend.core.tds.pandas_api.frames.functions.iloc import PandasApiIlocIndexer
+    from pylegend.core.tds.pandas_api.frames.functions.loc import PandasApiLocIndexer
 
 __all__: PyLegendSequence[str] = [
     "PandasApiBaseTdsFrame"
 ]
 
 R = PyLegendTypeVar('R')
+P = ParamSpec("P")
 
 
 class PandasApiBaseTdsFrame(PandasApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
@@ -73,9 +89,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 +116,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 +150,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 +272,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 +293,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 +312,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 +348,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 +366,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 +384,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 +402,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 +419,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 +445,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 +460,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 +610,256 @@ 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
+        )
+
+    @property
+    def iloc(self) -> "PandasApiIlocIndexer":
+        """
+        Purely integer-location based indexing for selection by position.
+        .iloc[] is primarily integer position based (from 0 to length-1 of the axis).
+
+        Allowed inputs are:
+        - An integer, e.g. 5.
+        - A slice object with ints, e.g. 1:7.
+        - A tuple of row and column indexes, e.g., (slice(1, 5), slice(0, 2))
+
+        Other pandas iloc features such as list of integers, boolean arrays, and callables
+        are not supported and will raise a NotImplementedError.
+        """
+        from pylegend.core.tds.pandas_api.frames.functions.iloc import PandasApiIlocIndexer
+        return PandasApiIlocIndexer(self)
+
+    @property
+    def loc(self) -> "PandasApiLocIndexer":
+        """
+        Access a group of rows and columns by label(s) or a boolean array.
+        .loc[] is primarily label based, but may also be used with a boolean array.
+
+        Allowed inputs are:
+        - A single label, e.g. 5 or 'a', (note that 5 is interpreted as a
+          label of the index, not as an integer position along the index).
+        - A list or array of labels, e.g. ['a', 'b', 'c'].
+        - A slice object with labels, e.g. 'a':'f'.
+        - A boolean array of the same length as the axis being sliced.
+        - A callable function with one argument (the calling Series or
+          DataFrame) and that returns valid output for indexing (one of the above).
+
+        Currently, for row selection, only callable function or complete slice are supported.
+        For column selection, string labels, lists of string labels, and slices of string labels are supported.
+        """
+        from pylegend.core.tds.pandas_api.frames.functions.loc import PandasApiLocIndexer
+        return PandasApiLocIndexer(self)
+
+    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,
@@ -40,11 +47,15 @@ from pylegend.core.tds.tds_frame import PyLegendTdsFrame
 if TYPE_CHECKING:
     from pylegend.core.language.pandas_api.pandas_api_series import Series
     from pylegend.core.tds.pandas_api.frames.pandas_api_groupby_tds_frame import PandasApiGroupbyTdsFrame
+    from pylegend.core.tds.pandas_api.frames.functions.iloc import PandasApiIlocIndexer
+    from pylegend.core.tds.pandas_api.frames.functions.loc import PandasApiLocIndexer
 
 __all__: PyLegendSequence[str] = [
     "PandasApiTdsFrame"
 ]
 
+P = ParamSpec("P")
+
 
 class PandasApiTdsFrame(PyLegendTdsFrame):
 
@@ -55,6 +66,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 +126,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 +202,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 +284,65 @@ 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
+
+    @property
+    @abstractmethod
+    def iloc(self) -> "PandasApiIlocIndexer":
+        pass  # pragma: no cover
+
+    @property
+    @abstractmethod
+    def loc(self) -> "PandasApiLocIndexer":
+        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