pylegend 0.7.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

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

@@ -0,0 +1,189 @@
+# Copyright 2025 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.
+
+from pylegend._typing import (
+    PyLegendUnion,
+    PyLegendOptional,
+    PyLegendCallable,
+    PyLegendList,
+    PyLegendSequence,
+)
+from pylegend.core.language.shared.tds_row import AbstractTdsRow
+from pylegend.core.sql.metamodel import (
+    QuerySpecification,
+    SortItemOrdering,
+    SortItem,
+    SortItemNullOrdering, SingleColumn, Expression,
+)
+from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import (
+    PandasApiAppliedFunction,
+)
+from pylegend.core.tds.pandas_api.frames.pandas_api_base_tds_frame import (
+    PandasApiBaseTdsFrame,
+)
+from pylegend.core.tds.sql_query_helpers import create_sub_query, copy_query
+from pylegend.core.tds.tds_frame import FrameToSqlConfig, FrameToPureConfig
+from pylegend.core.tds.tds_column import TdsColumn
+from pylegend.core.language.shared.helpers import escape_column_name
+
+
+class SortValuesFunction(PandasApiAppliedFunction):
+    __base_frame: PandasApiBaseTdsFrame
+    __by: PyLegendList[str]
+    __axis: PyLegendUnion[str, int]
+    __ascending: PyLegendList[bool]
+    __inplace: bool
+    __kind: PyLegendOptional[str]
+    __na_position: str
+    __ignore_index: bool
+    key: PyLegendOptional[PyLegendCallable[[AbstractTdsRow], AbstractTdsRow]] = None
+
+    @classmethod
+    def name(cls) -> str:
+        return "sort_values"  # pragma: no cover
+
+    def __init__(
+            self,
+            base_frame: PandasApiBaseTdsFrame,
+            by: PyLegendUnion[str, PyLegendList[str]],
+            axis: PyLegendUnion[str, int],
+            ascending: PyLegendUnion[bool, PyLegendList[bool]],
+            inplace: bool,
+            kind: PyLegendOptional[str],
+            na_position: str,
+            ignore_index: bool,
+            key: PyLegendOptional[PyLegendCallable[[AbstractTdsRow], AbstractTdsRow]] = None
+    ) -> None:
+        self.__base_frame = base_frame
+        self.__by_input = by
+        self.__axis = axis
+        self.__ascending_input = ascending
+        self.__inplace = inplace
+        self.__kind = kind
+        self.__na_position = na_position
+        self.__ignore_index = ignore_index
+        self.__key = key
+
+    def to_sql(self, config: FrameToSqlConfig) -> QuerySpecification:
+        base_query: QuerySpecification = self.__base_frame.to_sql_query_object(config)
+        should_create_sub_query = (base_query.offset is not None) or (base_query.limit is not None)
+        new_query = (
+            create_sub_query(base_query, config, "root") if should_create_sub_query
+            else copy_query(base_query)
+        )
+        new_query.orderBy = [
+            SortItem(
+                sortKey=self.get_expression_from_column_name(new_query, column_name, config),
+                ordering=(
+                    SortItemOrdering.ASCENDING if ascending
+                    else SortItemOrdering.DESCENDING
+                ),
+                nullOrdering=SortItemNullOrdering.UNDEFINED,
+            )
+            for column_name, ascending in zip(self.__by, self.__ascending)
+        ]
+        return new_query
+
+    def get_expression_from_column_name(self, query: QuerySpecification, column_name: str,
+                                        config: FrameToSqlConfig) -> Expression:
+        db_extension = config.sql_to_string_generator().get_db_extension()
+        filtered = [
+            s for s in query.select.selectItems
+            if (isinstance(s, SingleColumn) and
+                s.alias == db_extension.quote_identifier(column_name))
+        ]
+        if len(filtered) == 0:
+            raise RuntimeError("Cannot find column: " + column_name)  # pragma: no cover
+        return filtered[0].expression
+
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        escaped_columns = []
+        for col_name in self.__by:
+            escaped_columns.append(escape_column_name(col_name))
+        sort_items = [
+            f"~{column_name}->ascending()" if ascending else f"~{column_name}->descending()"
+            for column_name, ascending in zip(escaped_columns, self.__ascending)
+        ]
+        return (
+                f"{self.__base_frame.to_pure(config)}{config.separator(1)}"
+                + f"->sort([{', '.join(sort_items)}])"
+        )
+
+    def base_frame(self) -> PandasApiBaseTdsFrame:
+        return self.__base_frame
+
+    def tds_frame_parameters(self) -> PyLegendList["PandasApiBaseTdsFrame"]:
+        return []
+
+    def calculate_columns(self) -> PyLegendSequence["TdsColumn"]:
+        return [c.copy() for c in self.__base_frame.columns()]
+
+    def validate(self) -> bool:
+        if self.__axis not in [0, "index"]:
+            raise ValueError(
+                "Axis parameter of sort_values function must be 0 or 'index'"
+            )
+
+        if self.__inplace is not False:
+            raise ValueError("Inplace parameter of sort_values function must be False")
+
+        if self.__kind is not None:
+            raise NotImplementedError(
+                "Kind parameter of sort_values function is not supported"
+            )
+
+        if self.__ignore_index is not True:
+            raise ValueError(
+                "Ignore_index parameter of sort_values function must be True"
+            )
+
+        if self.__key is not None:
+            raise NotImplementedError(
+                "Key parameter of sort_values function is not supported"
+            )
+
+        base_frame_columns = [
+            column.get_name() for column in self.__base_frame.columns()
+        ]
+
+        self.__by = self._build_by_list()
+        self.__ascending = self._build_ascending_list()
+
+        if len(self.__by) != len(self.__ascending):
+            raise ValueError(
+                "The number of columns in 'by' must equal the number of values in 'ascending' for sort_values function."
+            )
+
+        for column in self.__by:
+            if column not in base_frame_columns:
+                raise ValueError(
+                    f"Column - '{column}' in sort_values columns list doesn't exist in the current frame. "
+                    f"Current frame columns: {base_frame_columns}"
+                )
+
+        return True
+
+    def _build_by_list(self) -> PyLegendList[str]:
+        if isinstance(self.__by_input, str):
+            return [self.__by_input]
+        else:
+            return self.__by_input
+
+    def _build_ascending_list(self) -> PyLegendList[bool]:
+        if self.__ascending_input is True:
+            return [True for _ in self.__by]
+        elif self.__ascending_input is False:
+            return [False for _ in self.__by]
+        else:
+            return self.__ascending_input

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

@@ -0,0 +1,120 @@
+# Copyright 2025 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.
+
+
+from datetime import date
+from pylegend._typing import (
+    PyLegendList,
+    PyLegendSequence,
+    PyLegendUnion,
+)
+from pylegend.core.sql.metamodel import LongLiteral, QuerySpecification
+from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import PandasApiAppliedFunction
+from pylegend.core.tds.pandas_api.frames.pandas_api_base_tds_frame import PandasApiBaseTdsFrame
+from pylegend.core.tds.sql_query_helpers import create_sub_query, copy_query
+from pylegend.core.tds.tds_column import TdsColumn
+from pylegend.core.tds.tds_frame import FrameToPureConfig, FrameToSqlConfig
+
+
+class TruncateFunction(PandasApiAppliedFunction):
+    __base_frame: PandasApiBaseTdsFrame
+    __before: int
+    __after: PyLegendUnion[int, None]
+    __axis: PyLegendUnion[str, int]
+    __copy: bool
+
+    @classmethod
+    def name(cls) -> str:
+        return "truncate"  # pragma: no cover
+
+    def __init__(
+            self,
+            base_frame: PandasApiBaseTdsFrame,
+            before: PyLegendUnion[date, str, int, None],
+            after: PyLegendUnion[date, str, int, None],
+            axis: PyLegendUnion[str, int],
+            copy: bool,
+    ) -> None:
+        self.__base_frame = base_frame
+        self.__before_input = before
+        self.__after_input = after
+        self.__axis = axis
+        self.__copy = copy
+
+    def to_sql(self, config: FrameToSqlConfig) -> QuerySpecification:
+        base_query: QuerySpecification = self.__base_frame.to_sql_query_object(config)
+        should_create_sub_query = (base_query.offset is not None) or (base_query.limit is not None)
+        new_query = create_sub_query(base_query, config, "root") if should_create_sub_query else copy_query(base_query)
+        new_query.offset = LongLiteral(self.__before)
+        if self.__after is not None:
+            new_query.limit = LongLiteral(self.__after - self.__before + 1)
+        return new_query
+
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        if self.__after is None:
+            return f"{self.__base_frame.to_pure(config)}{config.separator(1)}" f"->drop({self.__before})"
+
+        start_row = self.__before
+        end_row = self.__after + 1
+        return f"{self.__base_frame.to_pure(config)}{config.separator(1)}" f"->slice({start_row}, {end_row})"
+
+    def base_frame(self) -> PandasApiBaseTdsFrame:
+        return self.__base_frame
+
+    def tds_frame_parameters(self) -> PyLegendList["PandasApiBaseTdsFrame"]:
+        return []
+
+    def calculate_columns(self) -> PyLegendSequence["TdsColumn"]:
+        return [c.copy() for c in self.__base_frame.columns()]
+
+    def validate(self) -> bool:
+        if self.__axis not in [0, "index"]:
+            raise NotImplementedError(
+                f"The 'axis' parameter of the truncate function must be 0 or 'index', but got: {self.__axis}"
+            )
+
+        if self.__copy not in [True]:
+            raise NotImplementedError(f"The 'copy' parameter of the truncate function must be True, but got: {self.__copy}")
+
+        if self.__before_input is None:
+            self.__before = 0
+        else:
+            self.__before = self.get_positive_integer_or_raise_exception(self.__before_input, variable_name="before")
+
+        if self.__after_input is None:
+            self.__after = None
+            return True
+        else:
+            self.__after = self.get_positive_integer_or_raise_exception(self.__after_input, variable_name="after")
+
+            if self.__before > self.__after:
+                raise ValueError(
+                    f"The 'before' parameter of the truncate function must be less than or equal to the 'after' parameter, "
+                    f"but got: before={self.__before}, after={self.__after}"
+                )
+
+        return True
+
+    def get_positive_integer_or_raise_exception(
+        self, variable: PyLegendUnion[date, str, int, None], variable_name: str
+    ) -> int:
+        if type(variable) is not int:
+            raise NotImplementedError(
+                f"The '{variable_name}' parameter of the truncate function must be an integer, "
+                f"but got: {variable} (type: {type(variable).__name__})"
+            )
+
+        if variable < 0:
+            return 0
+        return variable

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

@@ -40,6 +40,10 @@ class PandasApiAppliedFunction(metaclass=ABCMeta):
     def to_sql(self, config: FrameToSqlConfig) -> QuerySpecification:
         pass  # pragma: no cover
 
+    @abstractmethod
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        pass  # pragma: no cover
+
     @abstractmethod
     def base_frame(self) -> PandasApiBaseTdsFrame:
         pass  # pragma: no cover
@@ -69,7 +73,7 @@ class PandasApiAppliedFunctionTdsFrame(PandasApiBaseTdsFrame):
         return self.__applied_function.to_sql(config)
 
     def to_pure(self, config: FrameToPureConfig) -> str:
-        raise RuntimeError("to_pure is not supported for PandasApiAppliedFunctionTdsFrame")
+        return self.__applied_function.to_pure(config)
 
     def get_all_tds_frames(self) -> PyLegendList["PandasApiBaseTdsFrame"]:
         return [

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

@@ -14,34 +14,46 @@
 
 from abc import ABCMeta, abstractmethod
 from datetime import date, datetime
+from typing import TYPE_CHECKING
+
 import pandas as pd
+
 from pylegend._typing import (
     PyLegendSequence,
     PyLegendTypeVar,
     PyLegendList,
+    PyLegendSet,
     PyLegendOptional,
     PyLegendCallable,
     PyLegendUnion,
 )
-from pylegend.core.sql.metamodel import QuerySpecification
 from pylegend.core.database.sql_to_string import (
     SqlToStringConfig,
     SqlToStringFormat
 )
-from pylegend.core.language import PyLegendPrimitive, LegacyApiTdsRow
+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
+from pylegend.core.language.shared.tds_row import AbstractTdsRow
+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.pandas_api_tds_frame import PandasApiTdsFrame
-from pylegend.core.tds.tds_column import TdsColumn
-from pylegend.core.tds.tds_frame import FrameToSqlConfig
-from pylegend.core.tds.tds_frame import FrameToPureConfig
 from pylegend.core.tds.result_handler import (
     ResultHandler,
     ToStringResultHandler,
 )
+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.extensions.tds.result_handler import (
     ToPandasDfResultHandler,
     PandasDfReadConfig,
 )
 
+if TYPE_CHECKING:
+    from pylegend.core.language.pandas_api.pandas_api_series import Series
+
 __all__: PyLegendSequence[str] = [
     "PandasApiBaseTdsFrame"
 ]
@@ -49,7 +61,7 @@ __all__: PyLegendSequence[str] = [
 R = PyLegendTypeVar('R')
 
 
-class PandasApiBaseTdsFrame(PandasApiTdsFrame, metaclass=ABCMeta):
+class PandasApiBaseTdsFrame(PandasApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
     __columns: PyLegendSequence[TdsColumn]
 
     def __init__(self, columns: PyLegendSequence[TdsColumn]) -> None:
@@ -62,10 +74,63 @@ class PandasApiBaseTdsFrame(PandasApiTdsFrame, metaclass=ABCMeta):
     def columns(self) -> PyLegendSequence[TdsColumn]:
         return [c.copy() for c in self.__columns]
 
+    def __getitem__(
+            self,
+            key: PyLegendUnion[str, PyLegendList[str], PyLegendBoolean]
+    ) -> PyLegendUnion["PandasApiTdsFrame", "Series"]:
+        from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import \
+            PandasApiAppliedFunctionTdsFrame
+        from pylegend.core.tds.pandas_api.frames.functions.filtering import \
+            PandasApiFilteringFunction
+        from pylegend.core.language.shared.primitives.boolean import PyLegendBoolean
+
+        if isinstance(key, PyLegendBoolean):
+            return PandasApiAppliedFunctionTdsFrame(
+                PandasApiFilteringFunction(self, filter_expr=key)
+            )
+
+        elif isinstance(key, str):
+            for col in self.__columns:
+                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
+                        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
+                        return StringSeries(self, key)
+                    elif col_type == "Integer":
+                        from pylegend.core.language.pandas_api.pandas_api_series import IntegerSeries
+                        return IntegerSeries(self, key)
+                    elif col_type == "Float":
+                        from pylegend.core.language.pandas_api.pandas_api_series import FloatSeries
+                        return FloatSeries(self, key)
+                    elif col_type == "Date":
+                        from pylegend.core.language.pandas_api.pandas_api_series import DateSeries
+                        return DateSeries(self, key)
+                    elif col_type == "DateTime":
+                        from pylegend.core.language.pandas_api.pandas_api_series import DateTimeSeries
+                        return DateTimeSeries(self, key)
+                    elif col_type == "StrictDate":
+                        from pylegend.core.language.pandas_api.pandas_api_series import StrictDateSeries
+                        return StrictDateSeries(self, key)
+                    else:
+                        raise ValueError(f"Unsupported column type '{col_type}' for column '{key}'")  # pragma: no cover
+            raise KeyError(f"['{key}'] not in index")
+
+        elif isinstance(key, list):
+            valid_col_names = {col.get_name() for col in self.__columns}
+            invalid_cols = [k for k in key if k not in valid_col_names]
+            if invalid_cols:
+                raise KeyError(f"{invalid_cols} not in index")
+            return self.filter(items=key)
+        else:
+            raise TypeError(f"Invalid key type: {type(key)}. Expected str, list, or boolean expression")
+
     def assign(
             self,
             **kwargs: PyLegendCallable[
-                [LegacyApiTdsRow],
+                [PandasApiTdsRow],
                 PyLegendUnion[int, float, bool, str, date, datetime, PyLegendPrimitive]
             ],
     ) -> "PandasApiTdsFrame":
@@ -75,6 +140,138 @@ class PandasApiBaseTdsFrame(PandasApiTdsFrame, metaclass=ABCMeta):
         from pylegend.core.tds.pandas_api.frames.functions.assign_function import AssignFunction
         return PandasApiAppliedFunctionTdsFrame(AssignFunction(self, col_definitions=kwargs))
 
+    def filter(
+            self,
+            items: PyLegendOptional[PyLegendList[str]] = None,
+            like: PyLegendOptional[str] = None,
+            regex: PyLegendOptional[str] = None,
+            axis: PyLegendOptional[PyLegendUnion[str, int, PyLegendInteger]] = None
+    ) -> "PandasApiTdsFrame":
+        from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import (
+            PandasApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.pandas_api.frames.functions.filter import PandasApiFilterFunction
+        return PandasApiAppliedFunctionTdsFrame(
+            PandasApiFilterFunction(
+                self,
+                items=items,
+                like=like,
+                regex=regex,
+                axis=axis
+            )
+        )
+
+    def sort_values(
+            self,
+            by: PyLegendUnion[str, PyLegendList[str]],
+            axis: PyLegendUnion[str, int] = 0,
+            ascending: PyLegendUnion[bool, PyLegendList[bool]] = True,
+            inplace: bool = False,
+            kind: PyLegendOptional[str] = None,
+            na_position: str = 'last',
+            ignore_index: bool = True,
+            key: PyLegendOptional[PyLegendCallable[[AbstractTdsRow], AbstractTdsRow]] = None
+    ) -> "PandasApiTdsFrame":
+        from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import (
+            PandasApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.pandas_api.frames.functions.sort_values_function import SortValuesFunction
+        return PandasApiAppliedFunctionTdsFrame(SortValuesFunction(
+            base_frame=self,
+            by=by,
+            axis=axis,
+            ascending=ascending,
+            inplace=inplace,
+            kind=kind,
+            na_position=na_position,
+            ignore_index=ignore_index,
+            key=key
+        ))
+
+    def truncate(
+            self,
+            before: PyLegendUnion[date, str, int, None] = None,
+            after: PyLegendUnion[date, str, int, None] = None,
+            axis: PyLegendUnion[str, int] = 0,
+            copy: bool = True
+    ) -> "PandasApiTdsFrame":
+        from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import (
+            PandasApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.pandas_api.frames.functions.truncate_function import TruncateFunction
+        return PandasApiAppliedFunctionTdsFrame(TruncateFunction(
+            base_frame=self,
+            before=before,
+            after=after,
+            axis=axis,
+            copy=copy
+        ))
+
+    def drop(
+            self,
+            labels: PyLegendOptional[PyLegendUnion[str, PyLegendSequence[str], PyLegendSet[str]]] = None,
+            axis: PyLegendUnion[str, int, PyLegendInteger] = 1,
+            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,
+            errors: str = "raise",
+    ) -> "PandasApiTdsFrame":
+        from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import \
+            PandasApiAppliedFunctionTdsFrame
+        from pylegend.core.tds.pandas_api.frames.functions.drop import PandasApiDropFunction
+
+        return PandasApiAppliedFunctionTdsFrame(
+            PandasApiDropFunction(
+                base_frame=self,
+                labels=labels,
+                axis=axis,
+                index=index,
+                columns=columns,
+                level=level,
+                inplace=inplace,
+                errors=errors
+            )
+        )
+
+    def aggregate(
+        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
+        )
+        from pylegend.core.tds.pandas_api.frames.functions.aggregate_function import AggregateFunction
+        return PandasApiAppliedFunctionTdsFrame(AggregateFunction(
+            self,
+            func,
+            axis,
+            *args,
+            **kwargs
+        ))
+
+    def agg(
+        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
+        )
+        from pylegend.core.tds.pandas_api.frames.functions.aggregate_function import AggregateFunction
+        return PandasApiAppliedFunctionTdsFrame(AggregateFunction(
+            self,
+            func,
+            axis,
+            *args,
+            **kwargs
+        ))
+
     @abstractmethod
     def to_sql_query_object(self, config: FrameToSqlConfig) -> QuerySpecification:
         pass  # pragma: no cover

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

@@ -17,6 +17,8 @@ from pylegend._typing import (
     PyLegendSequence,
     PyLegendList
 )
+from pylegend.core.tds.abstract.frames.input_tds_frame import InputTdsFrame, ExecutableInputTdsFrame, \
+    NonExecutableInputTdsFrame
 from pylegend.core.tds.tds_column import TdsColumn
 from pylegend.core.tds.pandas_api.frames.pandas_api_base_tds_frame import PandasApiBaseTdsFrame
 from pylegend.core.request.legend_client import LegendClient
@@ -29,7 +31,7 @@ __all__: PyLegendSequence[str] = [
 ]
 
 
-class PandasApiInputTdsFrame(PandasApiBaseTdsFrame, metaclass=ABCMeta):
+class PandasApiInputTdsFrame(PandasApiBaseTdsFrame, InputTdsFrame, metaclass=ABCMeta):
 
     def __init__(self, columns: PyLegendSequence[TdsColumn]) -> None:
         super().__init__(columns=columns)
@@ -38,7 +40,7 @@ class PandasApiInputTdsFrame(PandasApiBaseTdsFrame, metaclass=ABCMeta):
         return [self]
 
 
-class PandasApiExecutableInputTdsFrame(PandasApiInputTdsFrame, metaclass=ABCMeta):
+class PandasApiExecutableInputTdsFrame(PandasApiInputTdsFrame, ExecutableInputTdsFrame, metaclass=ABCMeta):
     __legend_client: LegendClient
 
     def __init__(self, legend_client: LegendClient, columns: PyLegendSequence[TdsColumn]) -> None:
@@ -49,7 +51,7 @@ class PandasApiExecutableInputTdsFrame(PandasApiInputTdsFrame, metaclass=ABCMeta
         return self.__legend_client
 
 
-class PandasApiNonExecutableInputTdsFrame(PandasApiInputTdsFrame, metaclass=ABCMeta):
+class PandasApiNonExecutableInputTdsFrame(PandasApiInputTdsFrame, NonExecutableInputTdsFrame, metaclass=ABCMeta):
 
     def __init__(self, columns: PyLegendSequence[TdsColumn]) -> None:
         super().__init__(columns=columns)