pylegend 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

pylegend/core/tds/{legend_api/frames/functions/rename_columns_function.py → legacy_api/frames/functions/legacy_api_rename_columns_function.py}

@@ -16,7 +16,7 @@ from pylegend._typing import (
     PyLegendList,
     PyLegendSequence,
 )
-from pylegend.core.tds.legend_api.frames.legend_api_applied_function_tds_frame import LegendApiAppliedFunction
+from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import LegacyApiAppliedFunction
 from pylegend.core.tds.sql_query_helpers import copy_query
 from pylegend.core.sql.metamodel import (
     QuerySpecification,
@@ -25,16 +25,18 @@ from pylegend.core.sql.metamodel import (
 )
 from pylegend.core.tds.tds_column import TdsColumn
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
-from pylegend.core.tds.legend_api.frames.legend_api_base_tds_frame import LegendApiBaseTdsFrame
+from pylegend.core.tds.tds_frame import FrameToPureConfig
+from pylegend.core.tds.legacy_api.frames.legacy_api_base_tds_frame import LegacyApiBaseTdsFrame
+from pylegend.core.language.shared.helpers import escape_column_name
 
 
 __all__: PyLegendSequence[str] = [
-    "RenameColumnsFunction"
+    "LegacyApiRenameColumnsFunction"
 ]
 
 
-class RenameColumnsFunction(LegendApiAppliedFunction):
-    __base_frame: LegendApiBaseTdsFrame
+class LegacyApiRenameColumnsFunction(LegacyApiAppliedFunction):
+    __base_frame: LegacyApiBaseTdsFrame
     __column_names: PyLegendList[str]
     __renamed_column_names: PyLegendList[str]
 
@@ -44,7 +46,7 @@ class RenameColumnsFunction(LegendApiAppliedFunction):
 
     def __init__(
             self,
-            base_frame: LegendApiBaseTdsFrame,
+            base_frame: LegacyApiBaseTdsFrame,
             column_names: PyLegendList[str],
             renamed_column_names: PyLegendList[str]
     ) -> None:
@@ -77,10 +79,20 @@ class RenameColumnsFunction(LegendApiAppliedFunction):
         new_query.select.selectItems = new_select_items
         return new_query
 
-    def base_frame(self) -> LegendApiBaseTdsFrame:
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        return (f"{self.__base_frame.to_pure(config)}{config.separator(1)}" +
+                f"{config.separator(1)}".join([
+                    f"->rename(~{x}, ~{y})"
+                    for x, y in zip(
+                        map(escape_column_name, self.__column_names),
+                        map(escape_column_name, self.__renamed_column_names)
+                    )
+                ]))
+
+    def base_frame(self) -> LegacyApiBaseTdsFrame:
         return self.__base_frame
 
-    def tds_frame_parameters(self) -> PyLegendList["LegendApiBaseTdsFrame"]:
+    def tds_frame_parameters(self) -> PyLegendList["LegacyApiBaseTdsFrame"]:
         return []
 
     def calculate_columns(self) -> PyLegendSequence["TdsColumn"]:

pylegend/core/tds/{legend_api/frames/functions/restrict_function.py → legacy_api/frames/functions/legacy_api_restrict_function.py}

@@ -17,7 +17,7 @@ from pylegend._typing import (
     PyLegendSequence,
     PyLegendTuple
 )
-from pylegend.core.tds.legend_api.frames.legend_api_applied_function_tds_frame import LegendApiAppliedFunction
+from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import LegacyApiAppliedFunction
 from pylegend.core.tds.sql_query_helpers import copy_query, create_sub_query
 from pylegend.core.sql.metamodel import (
     QuerySpecification,
@@ -26,23 +26,25 @@ from pylegend.core.sql.metamodel import (
 )
 from pylegend.core.tds.tds_column import TdsColumn
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
-from pylegend.core.tds.legend_api.frames.legend_api_base_tds_frame import LegendApiBaseTdsFrame
+from pylegend.core.tds.tds_frame import FrameToPureConfig
+from pylegend.core.tds.legacy_api.frames.legacy_api_base_tds_frame import LegacyApiBaseTdsFrame
+from pylegend.core.language.shared.helpers import escape_column_name
 
 
 __all__: PyLegendSequence[str] = [
-    "RestrictFunction"
+    "LegacyApiRestrictFunction"
 ]
 
 
-class RestrictFunction(LegendApiAppliedFunction):
-    __base_frame: LegendApiBaseTdsFrame
+class LegacyApiRestrictFunction(LegacyApiAppliedFunction):
+    __base_frame: LegacyApiBaseTdsFrame
     __column_name_list: PyLegendList[str]
 
     @classmethod
     def name(cls) -> str:
         return "restrict"
 
-    def __init__(self, base_frame: LegendApiBaseTdsFrame, column_name_list: PyLegendList[str]) -> None:
+    def __init__(self, base_frame: LegacyApiBaseTdsFrame, column_name_list: PyLegendList[str]) -> None:
         self.__base_frame = base_frame
         self.__column_name_list = column_name_list
 
@@ -74,10 +76,17 @@ class RestrictFunction(LegendApiAppliedFunction):
             new_query.select.selectItems = new_select_items
             return new_query
 
-    def base_frame(self) -> LegendApiBaseTdsFrame:
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        escaped_columns = []
+        for col_name in self.__column_name_list:
+            escaped_columns.append(escape_column_name(col_name))
+        return (f"{self.__base_frame.to_pure(config)}{config.separator(1)}" +
+                f"->select(~[{', '.join(escaped_columns)}])")
+
+    def base_frame(self) -> LegacyApiBaseTdsFrame:
         return self.__base_frame
 
-    def tds_frame_parameters(self) -> PyLegendList["LegendApiBaseTdsFrame"]:
+    def tds_frame_parameters(self) -> PyLegendList["LegacyApiBaseTdsFrame"]:
         return []
 
     def calculate_columns(self) -> PyLegendSequence["TdsColumn"]:

pylegend/core/tds/{legend_api/frames/functions/slice_function.py → legacy_api/frames/functions/legacy_api_slice_function.py}

@@ -16,7 +16,7 @@ from pylegend._typing import (
     PyLegendList,
     PyLegendSequence
 )
-from pylegend.core.tds.legend_api.frames.legend_api_applied_function_tds_frame import LegendApiAppliedFunction
+from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import LegacyApiAppliedFunction
 from pylegend.core.tds.sql_query_helpers import copy_query, create_sub_query
 from pylegend.core.sql.metamodel import (
     QuerySpecification,
@@ -24,16 +24,17 @@ from pylegend.core.sql.metamodel import (
 )
 from pylegend.core.tds.tds_column import TdsColumn
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
-from pylegend.core.tds.legend_api.frames.legend_api_base_tds_frame import LegendApiBaseTdsFrame
+from pylegend.core.tds.tds_frame import FrameToPureConfig
+from pylegend.core.tds.legacy_api.frames.legacy_api_base_tds_frame import LegacyApiBaseTdsFrame
 
 
 __all__: PyLegendSequence[str] = [
-    "SliceFunction"
+    "LegacyApiSliceFunction"
 ]
 
 
-class SliceFunction(LegendApiAppliedFunction):
-    __base_frame: LegendApiBaseTdsFrame
+class LegacyApiSliceFunction(LegacyApiAppliedFunction):
+    __base_frame: LegacyApiBaseTdsFrame
     __start_row: int
     __end_row: int
 
@@ -41,7 +42,7 @@ class SliceFunction(LegendApiAppliedFunction):
     def name(cls) -> str:
         return "slice"
 
-    def __init__(self, base_frame: LegendApiBaseTdsFrame, start_row: int, end_row: int) -> None:
+    def __init__(self, base_frame: LegacyApiBaseTdsFrame, start_row: int, end_row: int) -> None:
         self.__base_frame = base_frame
         self.__start_row = start_row
         self.__end_row = end_row
@@ -57,10 +58,14 @@ class SliceFunction(LegendApiAppliedFunction):
         new_query.limit = LongLiteral(self.__end_row - self.__start_row)
         return new_query
 
-    def base_frame(self) -> LegendApiBaseTdsFrame:
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        return (f"{self.__base_frame.to_pure(config)}{config.separator(1)}"
+                f"->slice({self.__start_row}, {self.__end_row})")
+
+    def base_frame(self) -> LegacyApiBaseTdsFrame:
         return self.__base_frame
 
-    def tds_frame_parameters(self) -> PyLegendList["LegendApiBaseTdsFrame"]:
+    def tds_frame_parameters(self) -> PyLegendList["LegacyApiBaseTdsFrame"]:
         return []
 
     def calculate_columns(self) -> PyLegendSequence["TdsColumn"]:

pylegend/core/tds/{legend_api/frames/functions/sort_function.py → legacy_api/frames/functions/legacy_api_sort_function.py}

@@ -17,7 +17,7 @@ from pylegend._typing import (
     PyLegendSequence,
     PyLegendOptional,
 )
-from pylegend.core.tds.legend_api.frames.legend_api_applied_function_tds_frame import LegendApiAppliedFunction
+from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import LegacyApiAppliedFunction
 from pylegend.core.tds.sql_query_helpers import copy_query, create_sub_query
 from pylegend.core.sql.metamodel import (
     QuerySpecification,
@@ -29,16 +29,18 @@ from pylegend.core.sql.metamodel import (
 )
 from pylegend.core.tds.tds_column import TdsColumn
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
-from pylegend.core.tds.legend_api.frames.legend_api_base_tds_frame import LegendApiBaseTdsFrame
+from pylegend.core.tds.tds_frame import FrameToPureConfig
+from pylegend.core.tds.legacy_api.frames.legacy_api_base_tds_frame import LegacyApiBaseTdsFrame
+from pylegend.core.language.shared.helpers import escape_column_name
 
 
 __all__: PyLegendSequence[str] = [
-    "SortFunction"
+    "LegacyApiSortFunction"
 ]
 
 
-class SortFunction(LegendApiAppliedFunction):
-    __base_frame: LegendApiBaseTdsFrame
+class LegacyApiSortFunction(LegacyApiAppliedFunction):
+    __base_frame: LegacyApiBaseTdsFrame
     __column_name_list: PyLegendList[str]
     __directions: PyLegendOptional[PyLegendList[str]]
 
@@ -48,7 +50,7 @@ class SortFunction(LegendApiAppliedFunction):
 
     def __init__(
             self,
-            base_frame: LegendApiBaseTdsFrame,
+            base_frame: LegacyApiBaseTdsFrame,
             column_name_list: PyLegendList[str],
             directions: PyLegendOptional[PyLegendList[str]]
     ) -> None:
@@ -89,10 +91,19 @@ class SortFunction(LegendApiAppliedFunction):
         ]
         return new_query
 
-    def base_frame(self) -> LegendApiBaseTdsFrame:
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        direction_list = self._build_directions_list()
+        sort_infos = []
+        for col_name, direction in zip(self.__column_name_list, direction_list):
+            escaped = escape_column_name(col_name)
+            sort_infos.append(f"{'ascending' if direction.upper() == 'ASC' else 'descending'}(~{escaped})")
+        return (f"{self.__base_frame.to_pure(config)}{config.separator(1)}" +
+                f"->sort([{', '.join(sort_infos)}])")
+
+    def base_frame(self) -> LegacyApiBaseTdsFrame:
         return self.__base_frame
 
-    def tds_frame_parameters(self) -> PyLegendList["LegendApiBaseTdsFrame"]:
+    def tds_frame_parameters(self) -> PyLegendList["LegacyApiBaseTdsFrame"]:
         return []
 
     def calculate_columns(self) -> PyLegendSequence["TdsColumn"]:

pylegend/core/tds/legacy_api/frames/legacy_api_applied_function_tds_frame.py

@@ -0,0 +1,37 @@
+# Copyright 2023 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 abc import ABCMeta, abstractmethod
+from pylegend._typing import (
+    PyLegendSequence,
+)
+from pylegend.core.tds.abstract.frames.applied_function_tds_frame import AppliedFunction, AppliedFunctionTdsFrame
+from pylegend.core.tds.legacy_api.frames.legacy_api_base_tds_frame import LegacyApiBaseTdsFrame
+
+
+__all__: PyLegendSequence[str] = [
+    "LegacyApiAppliedFunctionTdsFrame",
+    "LegacyApiAppliedFunction",
+]
+
+
+class LegacyApiAppliedFunction(AppliedFunction, metaclass=ABCMeta):
+    @abstractmethod
+    def tds_frame_parameters(self) -> PyLegendSequence["LegacyApiBaseTdsFrame"]:
+        pass  # pragma: no cover
+
+
+class LegacyApiAppliedFunctionTdsFrame(LegacyApiBaseTdsFrame, AppliedFunctionTdsFrame):
+    def __init__(self, applied_function: LegacyApiAppliedFunction):
+        AppliedFunctionTdsFrame.__init__(self, applied_function)

pylegend/core/tds/legacy_api/frames/legacy_api_base_tds_frame.py

@@ -0,0 +1,204 @@
+# Copyright 2023 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 abc import ABCMeta
+
+from pylegend._typing import (
+    PyLegendSequence,
+    PyLegendTypeVar,
+    PyLegendList,
+    PyLegendOptional,
+    PyLegendCallable,
+    PyLegendUnion,
+)
+from pylegend.core.language import (
+    LegacyApiTdsRow,
+    PyLegendBoolean,
+    PyLegendPrimitiveOrPythonPrimitive,
+    LegacyApiAggregateSpecification,
+)
+from pylegend.core.tds.abstract.frames.base_tds_frame import BaseTdsFrame
+from pylegend.core.tds.legacy_api.frames.legacy_api_tds_frame import LegacyApiTdsFrame
+from pylegend.core.tds.tds_column import TdsColumn
+
+__all__: PyLegendSequence[str] = [
+    "LegacyApiBaseTdsFrame"
+]
+
+R = PyLegendTypeVar('R')
+
+
+class LegacyApiBaseTdsFrame(LegacyApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
+
+    def __init__(self, columns: PyLegendSequence[TdsColumn]) -> None:
+        BaseTdsFrame.__init__(self, columns=columns)
+
+    def head(self, row_count: int = 5) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_head_function import (
+            LegacyApiHeadFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(LegacyApiHeadFunction(self, row_count))
+
+    def take(self, row_count: int = 5) -> "LegacyApiTdsFrame":
+        return self.head(row_count=row_count)
+
+    def limit(self, row_count: int = 5) -> "LegacyApiTdsFrame":
+        return self.head(row_count=row_count)
+
+    def drop(self, row_count: int = 5) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_drop_function import (
+            LegacyApiDropFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(LegacyApiDropFunction(self, row_count))
+
+    def slice(self, start_row: int, end_row_exclusive: int) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_slice_function import (
+            LegacyApiSliceFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(LegacyApiSliceFunction(self, start_row, end_row_exclusive))
+
+    def distinct(self) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_distinct_function import (
+            LegacyApiDistinctFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(LegacyApiDistinctFunction(self))
+
+    def restrict(self, column_name_list: PyLegendList[str]) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_restrict_function import (
+            LegacyApiRestrictFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(LegacyApiRestrictFunction(self, column_name_list))
+
+    def sort(
+            self,
+            column_name_list: PyLegendList[str],
+            direction_list: PyLegendOptional[PyLegendList[str]] = None
+    ) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_sort_function import (
+            LegacyApiSortFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(LegacyApiSortFunction(self, column_name_list, direction_list))
+
+    def concatenate(self, other: "LegacyApiTdsFrame") -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_concatenate_function import (
+            LegacyApiConcatenateFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(LegacyApiConcatenateFunction(self, other))
+
+    def rename_columns(
+            self,
+            column_names: PyLegendList[str],
+            renamed_column_names: PyLegendList[str]
+    ) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_rename_columns_function import (
+            LegacyApiRenameColumnsFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(LegacyApiRenameColumnsFunction(self, column_names, renamed_column_names))
+
+    def filter(
+            self,
+            filter_function: PyLegendCallable[[LegacyApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]]
+    ) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_filter_function import (
+            LegacyApiFilterFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(LegacyApiFilterFunction(self, filter_function))
+
+    def extend(
+            self,
+            functions_list: PyLegendList[PyLegendCallable[[LegacyApiTdsRow], PyLegendPrimitiveOrPythonPrimitive]],
+            column_names_list: PyLegendList[str]
+    ) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_extend_function import (
+            LegacyApiExtendFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(LegacyApiExtendFunction(self, functions_list, column_names_list))
+
+    def join(
+            self,
+            other: "LegacyApiTdsFrame",
+            join_condition: PyLegendCallable[[LegacyApiTdsRow, LegacyApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]],
+            join_type: str = 'LEFT_OUTER'
+    ) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_join_function import (
+            LegacyApiJoinFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(
+            LegacyApiJoinFunction(self, other, join_condition, join_type)
+        )
+
+    def join_by_columns(
+            self,
+            other: "LegacyApiTdsFrame",
+            self_columns: PyLegendList[str],
+            other_columns: PyLegendList[str],
+            join_type: str = 'LEFT_OUTER'
+    ) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_join_by_columns_function import (
+            LegacyApiJoinByColumnsFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(
+            LegacyApiJoinByColumnsFunction(self, other, self_columns, other_columns, join_type)
+        )
+
+    def group_by(
+            self,
+            grouping_columns: PyLegendList[str],
+            aggregations: PyLegendList[LegacyApiAggregateSpecification],
+    ) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_group_by_function import (
+            LegacyApiGroupByFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(
+            LegacyApiGroupByFunction(self, grouping_columns, aggregations)
+        )

pylegend/core/tds/legacy_api/frames/legacy_api_input_tds_frame.py

@@ -0,0 +1,51 @@
+# Copyright 2023 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 abc import ABCMeta
+from pylegend._typing import (
+    PyLegendSequence,
+)
+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.legacy_api.frames.legacy_api_base_tds_frame import LegacyApiBaseTdsFrame
+from pylegend.core.request.legend_client import LegendClient
+
+
+__all__: PyLegendSequence[str] = [
+    "LegacyApiExecutableInputTdsFrame",
+    "LegacyApiNonExecutableInputTdsFrame",
+    "LegacyApiInputTdsFrame"
+]
+
+
+class LegacyApiInputTdsFrame(LegacyApiBaseTdsFrame, InputTdsFrame, metaclass=ABCMeta):
+    def __init__(self, columns: PyLegendSequence[TdsColumn]) -> None:
+        LegacyApiBaseTdsFrame.__init__(self, columns=columns)
+        InputTdsFrame.__init__(self, columns=columns)
+
+
+class LegacyApiExecutableInputTdsFrame(LegacyApiInputTdsFrame, ExecutableInputTdsFrame, metaclass=ABCMeta):
+    def __init__(self, legend_client: LegendClient, columns: PyLegendSequence[TdsColumn]) -> None:
+        LegacyApiInputTdsFrame.__init__(self, columns=columns)
+        ExecutableInputTdsFrame.__init__(self, legend_client=legend_client, columns=columns)
+
+
+class LegacyApiNonExecutableInputTdsFrame(LegacyApiInputTdsFrame, NonExecutableInputTdsFrame, metaclass=ABCMeta):
+    def __init__(self, columns: PyLegendSequence[TdsColumn]) -> None:
+        LegacyApiInputTdsFrame.__init__(self, columns=columns)
+        NonExecutableInputTdsFrame.__init__(self, columns=columns)