pylegend 0.2.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

pylegend/core/tds/legendql_api/frames/legendql_api_tds_frame.py

@@ -0,0 +1,327 @@
+# 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 abc import ABCMeta, abstractmethod
+
+from pylegend.core.language import PyLegendBoolean, PyLegendPrimitiveOrPythonPrimitive, PyLegendPrimitiveCollection, \
+    PyLegendPrimitive
+from pylegend.core.language.legendql_api.legendql_api_custom_expressions import (
+    LegendQLApiPrimitive,
+    LegendQLApiSortInfo,
+    LegendQLApiWindow,
+    LegendQLApiPartialFrame,
+    LegendQLApiWindowReference,
+)
+from pylegend.core.language.legendql_api.legendql_api_tds_row import LegendQLApiTdsRow
+from pylegend.core.tds.tds_frame import (
+    PyLegendTdsFrame
+)
+from pylegend._typing import (
+    PyLegendSequence,
+    PyLegendCallable,
+    PyLegendUnion,
+    PyLegendList,
+    PyLegendOptional,
+    PyLegendTuple,
+)
+
+__all__: PyLegendSequence[str] = [
+    "LegendQLApiTdsFrame"
+]
+
+
+class LegendQLApiTdsFrame(PyLegendTdsFrame, metaclass=ABCMeta):
+
+    @abstractmethod
+    def head(self, count: int = 5) -> "LegendQLApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def limit(self, count: int = 5) -> "LegendQLApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def drop(self, count: int = 5) -> "LegendQLApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def slice(self, start_row: int, end_row_exclusive: int) -> "LegendQLApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def distinct(self) -> "LegendQLApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def select(
+            self,
+            columns: PyLegendUnion[
+                str,
+                PyLegendList[str],
+                PyLegendCallable[
+                    [LegendQLApiTdsRow],
+                    PyLegendUnion[LegendQLApiPrimitive, PyLegendList[LegendQLApiPrimitive]]
+                ]
+            ]
+    ) -> "LegendQLApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def sort(
+            self,
+            sort_infos: PyLegendUnion[
+                str,
+                PyLegendList[str],
+                PyLegendCallable[
+                    [LegendQLApiTdsRow],
+                    PyLegendUnion[
+                        LegendQLApiPrimitive,
+                        LegendQLApiSortInfo,
+                        PyLegendList[PyLegendUnion[LegendQLApiPrimitive, LegendQLApiSortInfo]],
+                    ]
+                ]
+            ]
+    ) -> "LegendQLApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def concatenate(self, other: "LegendQLApiTdsFrame") -> "LegendQLApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def filter(
+            self,
+            filter_function: PyLegendCallable[[LegendQLApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]]
+    ) -> "LegendQLApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def rename(
+            self,
+            column_renames: PyLegendUnion[
+                PyLegendTuple[str, str],
+                PyLegendList[PyLegendTuple[str, str]],
+                PyLegendCallable[
+                    [LegendQLApiTdsRow],
+                    PyLegendUnion[
+                        PyLegendTuple[LegendQLApiPrimitive, str],
+                        PyLegendList[PyLegendTuple[LegendQLApiPrimitive, str]]
+                    ]
+                ]
+            ]
+    ) -> "LegendQLApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def extend(
+            self,
+            extend_columns: PyLegendUnion[
+                PyLegendTuple[
+                    str,
+                    PyLegendCallable[[LegendQLApiTdsRow], PyLegendPrimitiveOrPythonPrimitive]
+                ],
+                PyLegendTuple[
+                    str,
+                    PyLegendCallable[[LegendQLApiTdsRow], PyLegendPrimitiveOrPythonPrimitive],
+                    PyLegendCallable[[PyLegendPrimitiveCollection], PyLegendPrimitive]
+                ],
+                PyLegendList[
+                    PyLegendUnion[
+                        PyLegendTuple[
+                            str,
+                            PyLegendCallable[[LegendQLApiTdsRow], PyLegendPrimitiveOrPythonPrimitive]
+                        ],
+                        PyLegendTuple[
+                            str,
+                            PyLegendCallable[[LegendQLApiTdsRow], PyLegendPrimitiveOrPythonPrimitive],
+                            PyLegendCallable[[PyLegendPrimitiveCollection], PyLegendPrimitive]
+                        ]
+                    ]
+                ]
+            ]
+    ) -> "LegendQLApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def join(
+            self,
+            other: "LegendQLApiTdsFrame",
+            join_condition: PyLegendCallable[
+                [LegendQLApiTdsRow, LegendQLApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]
+            ],
+            join_type: str = 'LEFT_OUTER'
+    ) -> "LegendQLApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def inner_join(
+            self,
+            other: "LegendQLApiTdsFrame",
+            join_condition: PyLegendCallable[
+                [LegendQLApiTdsRow, LegendQLApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]
+            ]
+    ) -> "LegendQLApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def left_join(
+            self,
+            other: "LegendQLApiTdsFrame",
+            join_condition: PyLegendCallable[
+                [LegendQLApiTdsRow, LegendQLApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]
+            ]
+    ) -> "LegendQLApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def right_join(
+            self,
+            other: "LegendQLApiTdsFrame",
+            join_condition: PyLegendCallable[
+                [LegendQLApiTdsRow, LegendQLApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]
+            ]
+    ) -> "LegendQLApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def as_of_join(
+            self,
+            other: "LegendQLApiTdsFrame",
+            match_function: PyLegendCallable[
+                [LegendQLApiTdsRow, LegendQLApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]
+            ],
+            join_condition: PyLegendOptional[
+                PyLegendCallable[[LegendQLApiTdsRow, LegendQLApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]]
+            ] = None
+    ) -> "LegendQLApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def group_by(
+            self,
+            grouping_columns: PyLegendUnion[
+                str,
+                PyLegendList[str],
+                PyLegendCallable[
+                    [LegendQLApiTdsRow],
+                    PyLegendUnion[LegendQLApiPrimitive, PyLegendList[LegendQLApiPrimitive]]
+                ]
+            ],
+            aggregate_specifications: PyLegendUnion[
+                PyLegendTuple[
+                    str,
+                    PyLegendCallable[[LegendQLApiTdsRow], PyLegendPrimitiveOrPythonPrimitive],
+                    PyLegendCallable[[PyLegendPrimitiveCollection], PyLegendPrimitive]
+                ],
+                PyLegendList[
+                    PyLegendTuple[
+                        str,
+                        PyLegendCallable[[LegendQLApiTdsRow], PyLegendPrimitiveOrPythonPrimitive],
+                        PyLegendCallable[[PyLegendPrimitiveCollection], PyLegendPrimitive]
+                    ]
+                ]
+            ]
+    ) -> "LegendQLApiTdsFrame":
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def window(
+            self,
+            partition_by: PyLegendOptional[
+                PyLegendUnion[
+                    str,
+                    PyLegendList[str],
+                    PyLegendCallable[
+                        [LegendQLApiTdsRow],
+                        PyLegendUnion[LegendQLApiPrimitive, PyLegendList[LegendQLApiPrimitive]]
+                    ]
+                ]
+            ] = None,
+            order_by: PyLegendOptional[
+                PyLegendUnion[
+                    str,
+                    PyLegendList[str],
+                    PyLegendCallable[
+                        [LegendQLApiTdsRow],
+                        PyLegendUnion[
+                            LegendQLApiPrimitive,
+                            LegendQLApiSortInfo,
+                            PyLegendList[PyLegendUnion[LegendQLApiPrimitive, LegendQLApiSortInfo]],
+                        ]
+                    ]
+                ]
+            ] = None
+    ) -> LegendQLApiWindow:
+        pass
+
+    @abstractmethod
+    def window_extend(
+            self,
+            window: LegendQLApiWindow,
+            extend_columns: PyLegendUnion[
+                PyLegendTuple[
+                    str,
+                    PyLegendCallable[
+                        [LegendQLApiPartialFrame, LegendQLApiWindowReference, LegendQLApiTdsRow],
+                        PyLegendPrimitiveOrPythonPrimitive
+                    ]
+                ],
+                PyLegendTuple[
+                    str,
+                    PyLegendCallable[
+                        [LegendQLApiPartialFrame, LegendQLApiWindowReference, LegendQLApiTdsRow],
+                        PyLegendPrimitiveOrPythonPrimitive
+                    ],
+                    PyLegendCallable[[PyLegendPrimitiveCollection], PyLegendPrimitive]
+                ],
+                PyLegendList[
+                    PyLegendUnion[
+                        PyLegendTuple[
+                            str,
+                            PyLegendCallable[
+                                [LegendQLApiPartialFrame, LegendQLApiWindowReference, LegendQLApiTdsRow],
+                                PyLegendPrimitiveOrPythonPrimitive
+                            ]
+                        ],
+                        PyLegendTuple[
+                            str,
+                            PyLegendCallable[
+                                [LegendQLApiPartialFrame, LegendQLApiWindowReference, LegendQLApiTdsRow],
+                                PyLegendPrimitiveOrPythonPrimitive
+                            ],
+                            PyLegendCallable[[PyLegendPrimitiveCollection], PyLegendPrimitive]
+                        ]
+                    ]
+                ]
+            ]
+    ) -> "LegendQLApiTdsFrame":
+        pass
+
+    @abstractmethod
+    def project(
+            self,
+            project_columns: PyLegendUnion[
+                PyLegendTuple[
+                    str,
+                    PyLegendCallable[[LegendQLApiTdsRow], PyLegendPrimitiveOrPythonPrimitive]
+                ],
+                PyLegendList[
+                    PyLegendTuple[
+                        str,
+                        PyLegendCallable[[LegendQLApiTdsRow], PyLegendPrimitiveOrPythonPrimitive]
+                    ]
+                ]
+            ]
+    ) -> "LegendQLApiTdsFrame":
+        pass  # pragma: no cover

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

@@ -30,7 +30,7 @@ from pylegend.core.tds.pandas_api.frames.pandas_api_base_tds_frame import Pandas
 from pylegend.core.tds.tds_column import TdsColumn, PrimitiveTdsColumn
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
 from pylegend.core.language import (
-    TdsRow,
+    LegacyApiTdsRow,
     PyLegendPrimitive,
     PyLegendInteger,
     PyLegendFloat,
@@ -44,7 +44,7 @@ class AssignFunction(PandasApiAppliedFunction):
     __base_frame: PandasApiBaseTdsFrame
     __col_definitions: PyLegendDict[
         str,
-        PyLegendCallable[[TdsRow], PyLegendUnion[int, float, bool, str, date, datetime, PyLegendPrimitive]],
+        PyLegendCallable[[LegacyApiTdsRow], PyLegendUnion[int, float, bool, str, date, datetime, PyLegendPrimitive]],
     ]
 
     @classmethod
@@ -56,7 +56,7 @@ class AssignFunction(PandasApiAppliedFunction):
             base_frame: PandasApiBaseTdsFrame,
             col_definitions: PyLegendDict[
                 str,
-                PyLegendCallable[[TdsRow], PyLegendUnion[int, float, bool, str, date, datetime, PyLegendPrimitive]],
+                PyLegendCallable[[LegacyApiTdsRow], PyLegendUnion[int, float, bool, str, date, datetime, PyLegendPrimitive]],
             ]
     ) -> None:
         self.__base_frame = base_frame
@@ -72,7 +72,7 @@ class AssignFunction(PandasApiAppliedFunction):
             copy_query(base_query)
         )
 
-        tds_row = TdsRow.from_tds_frame("frame", self.__base_frame)
+        tds_row = LegacyApiTdsRow.from_tds_frame("frame", self.__base_frame)
         for col, func in self.__col_definitions.items():
             res = func(tds_row)
             if not isinstance(res, PyLegendPrimitive):
@@ -94,7 +94,7 @@ class AssignFunction(PandasApiAppliedFunction):
 
     def calculate_columns(self) -> PyLegendSequence["TdsColumn"]:
         new_cols = [c.copy() for c in self.__base_frame.columns()]
-        tds_row = TdsRow.from_tds_frame("frame", self.__base_frame)
+        tds_row = LegacyApiTdsRow.from_tds_frame("frame", self.__base_frame)
         for col, func in self.__col_definitions.items():
             res = func(tds_row)
             if isinstance(res, (int, PyLegendInteger)):
@@ -112,7 +112,7 @@ class AssignFunction(PandasApiAppliedFunction):
         return new_cols
 
     def validate(self) -> bool:
-        tds_row = TdsRow.from_tds_frame("frame", self.__base_frame)
+        tds_row = LegacyApiTdsRow.from_tds_frame("frame", self.__base_frame)
         for col, f in self.__col_definitions.items():
             f(tds_row)
         return True

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

@@ -20,6 +20,7 @@ from pylegend._typing import (
 from pylegend.core.sql.metamodel import QuerySpecification
 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.pandas_api.frames.pandas_api_base_tds_frame import PandasApiBaseTdsFrame
 
 
@@ -67,6 +68,9 @@ class PandasApiAppliedFunctionTdsFrame(PandasApiBaseTdsFrame):
     def to_sql_query_object(self, config: FrameToSqlConfig) -> QuerySpecification:
         return self.__applied_function.to_sql(config)
 
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        raise RuntimeError("to_pure is not supported for PandasApiAppliedFunctionTdsFrame")
+
     def get_all_tds_frames(self) -> PyLegendList["PandasApiBaseTdsFrame"]:
         return [
             y

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

@@ -24,14 +24,15 @@ from pylegend._typing import (
     PyLegendUnion,
 )
 from pylegend.core.sql.metamodel import QuerySpecification
-from pylegend.core.databse.sql_to_string import (
+from pylegend.core.database.sql_to_string import (
     SqlToStringConfig,
     SqlToStringFormat
 )
-from pylegend.core.language import PyLegendPrimitive, TdsRow
+from pylegend.core.language import PyLegendPrimitive, LegacyApiTdsRow
 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,
@@ -64,7 +65,7 @@ class PandasApiBaseTdsFrame(PandasApiTdsFrame, metaclass=ABCMeta):
     def assign(
             self,
             **kwargs: PyLegendCallable[
-                [TdsRow],
+                [LegacyApiTdsRow],
                 PyLegendUnion[int, float, bool, str, date, datetime, PyLegendPrimitive]
             ],
     ) -> "PandasApiTdsFrame":
@@ -78,6 +79,13 @@ class PandasApiBaseTdsFrame(PandasApiTdsFrame, metaclass=ABCMeta):
     def to_sql_query_object(self, config: FrameToSqlConfig) -> QuerySpecification:
         pass  # pragma: no cover
 
+    @abstractmethod
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        pass  # pragma: no cover
+
+    def to_pure_query(self, config: FrameToPureConfig = FrameToPureConfig()) -> str:
+        return self.to_pure(config)
+
     @abstractmethod
     def get_all_tds_frames(self) -> PyLegendList["PandasApiBaseTdsFrame"]:
         pass  # pragma: no cover

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

@@ -21,7 +21,7 @@ from pylegend._typing import (
 )
 from pylegend.core.tds.tds_frame import PyLegendTdsFrame
 from pylegend.core.language import (
-    TdsRow,
+    LegacyApiTdsRow,
     PyLegendPrimitive,
 )
 
@@ -36,7 +36,7 @@ class PandasApiTdsFrame(PyLegendTdsFrame):
     def assign(
             self,
             **kwargs: PyLegendCallable[
-                [TdsRow],
+                [LegacyApiTdsRow],
                 PyLegendUnion[int, float, bool, str, date, datetime, PyLegendPrimitive]
             ],
     ) -> "PandasApiTdsFrame":

pylegend/core/tds/tds_frame.py

@@ -21,7 +21,7 @@ from pylegend._typing import (
     PyLegendOptional,
 )
 from pylegend.core.tds.tds_column import TdsColumn
-from pylegend.core.databse.sql_to_string import SqlToStringGenerator
+from pylegend.core.database.sql_to_string import SqlToStringGenerator
 from pylegend.core.tds.result_handler import ResultHandler
 from pylegend.extensions.tds.result_handler import PandasDfReadConfig
 
@@ -30,7 +30,8 @@ importlib.import_module(postgres_ext)
 
 __all__: PyLegendSequence[str] = [
     "PyLegendTdsFrame",
-    "FrameToSqlConfig"
+    "FrameToSqlConfig",
+    "FrameToPureConfig",
 ]
 
 
@@ -56,6 +57,31 @@ class FrameToSqlConfig:
         return self.__sql_to_string_generator
 
 
+class FrameToPureConfig:
+    __pretty: bool
+    __indent: str
+    __indent_level: int
+
+    def __init__(
+            self,
+            pretty: bool = True,
+            ident: str = "  ",
+            indent_level: int = 0,
+    ) -> None:
+        self.__pretty = pretty
+        self.__indent = ident
+        self.__indent_level = indent_level
+
+    def push_indent(self, extra_indent_level: int = 1) -> "FrameToPureConfig":
+        return FrameToPureConfig(self.__pretty, self.__indent, self.__indent_level + extra_indent_level)
+
+    def separator(self, extra_indent_level: int = 0, return_space_if_not_pretty: bool = False) -> str:
+        if self.__pretty:
+            return "\n" + (self.__indent * (self.__indent_level + extra_indent_level))
+        else:
+            return " " if return_space_if_not_pretty else ""
+
+
 R = PyLegendTypeVar('R')
 
 
@@ -69,6 +95,10 @@ class PyLegendTdsFrame(metaclass=ABCMeta):
     def to_sql_query(self, config: FrameToSqlConfig = FrameToSqlConfig()) -> str:
         pass  # pragma: no cover
 
+    @abstractmethod
+    def to_pure_query(self, config: FrameToPureConfig = FrameToPureConfig()) -> str:
+        pass  # pragma: no cover
+
     @abstractmethod
     def execute_frame(
             self,

pylegend/extensions/database/vendors/postgres/postgres_sql_to_string.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from pylegend.core.databse.sql_to_string import (
+from pylegend.core.database.sql_to_string import (
     SqlToStringGenerator,
     SqlToStringDbExtension,
 )

pylegend/extensions/tds/abstract/legend_function_input_frame.py

@@ -20,6 +20,7 @@ from pylegend._typing import (
 from pylegend.core.tds.tds_frame import (
     PyLegendTdsFrame,
     FrameToSqlConfig,
+    FrameToPureConfig,
 )
 from pylegend.core.project_cooridnates import ProjectCoordinates
 from pylegend.core.sql.metamodel import (
@@ -101,6 +102,9 @@ class LegendFunctionInputFrameAbstract(PyLegendTdsFrame, metaclass=ABCMeta):
             offset=None
         )
 
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        raise RuntimeError("to_pure is not supported for LegendFunctionInputFrame")
+
     def get_path(self) -> str:
         return self.__path
 

pylegend/extensions/tds/abstract/legend_service_input_frame.py

@@ -20,6 +20,7 @@ from pylegend._typing import (
 from pylegend.core.tds.tds_frame import (
     PyLegendTdsFrame,
     FrameToSqlConfig,
+    FrameToPureConfig,
 )
 from pylegend.core.project_cooridnates import ProjectCoordinates
 from pylegend.core.sql.metamodel import (
@@ -101,6 +102,9 @@ class LegendServiceInputFrameAbstract(PyLegendTdsFrame, metaclass=ABCMeta):
             offset=None
         )
 
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        raise RuntimeError("to_pure is not supported for LegendServiceInputFrame")
+
     def get_pattern(self) -> str:
         return self.__pattern
 

pylegend/extensions/tds/abstract/table_spec_input_frame.py

@@ -28,6 +28,7 @@ from pylegend.core.sql.metamodel import (
 )
 from pylegend.core.tds.tds_frame import PyLegendTdsFrame
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.core.tds.tds_frame import FrameToPureConfig
 
 __all__: PyLegendSequence[str] = [
     "TableSpecInputFrameAbstract",
@@ -68,3 +69,6 @@ class TableSpecInputFrameAbstract(PyLegendTdsFrame, metaclass=ABCMeta):
             limit=None,
             offset=None
         )
+
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        return f"#Table({'.'.join(self.table.parts)})#"

pylegend/extensions/tds/{legend_api/frames/legend_api_legend_function_input_frame.py → legacy_api/frames/legacy_api_legend_function_input_frame.py}

@@ -15,18 +15,18 @@
 from pylegend._typing import (
     PyLegendSequence
 )
-from pylegend.core.tds.legend_api.frames.legend_api_input_tds_frame import LegendApiExecutableInputTdsFrame
+from pylegend.core.tds.legacy_api.frames.legacy_api_input_tds_frame import LegacyApiExecutableInputTdsFrame
 from pylegend.core.project_cooridnates import ProjectCoordinates
 from pylegend.core.request.legend_client import LegendClient
 from pylegend.extensions.tds.abstract.legend_function_input_frame import LegendFunctionInputFrameAbstract
 
 
 __all__: PyLegendSequence[str] = [
-    "LegendApiLegendFunctionInputFrame"
+    "LegacyApiLegendFunctionInputFrame"
 ]
 
 
-class LegendApiLegendFunctionInputFrame(LegendFunctionInputFrameAbstract, LegendApiExecutableInputTdsFrame):
+class LegacyApiLegendFunctionInputFrame(LegendFunctionInputFrameAbstract, LegacyApiExecutableInputTdsFrame):
 
     def __init__(
             self,
@@ -35,7 +35,7 @@ class LegendApiLegendFunctionInputFrame(LegendFunctionInputFrameAbstract, Legend
             legend_client: LegendClient,
     ) -> None:
         LegendFunctionInputFrameAbstract.__init__(self, path=path, project_coordinates=project_coordinates)
-        LegendApiExecutableInputTdsFrame.__init__(
+        LegacyApiExecutableInputTdsFrame.__init__(
             self,
             legend_client=legend_client,
             columns=legend_client.get_sql_string_schema(self.to_sql_query())
@@ -43,4 +43,4 @@ class LegendApiLegendFunctionInputFrame(LegendFunctionInputFrameAbstract, Legend
         LegendFunctionInputFrameAbstract.set_initialized(self, True)
 
     def __str__(self) -> str:
-        return f"LegendApiLegendFunctionInputFrame({'.'.join(self.get_path())})"
+        return f"LegacyApiLegendFunctionInputFrame({'.'.join(self.get_path())})"

pylegend/extensions/tds/{legend_api/frames/legend_api_legend_service_input_frame.py → legacy_api/frames/legacy_api_legend_service_input_frame.py}

@@ -15,18 +15,18 @@
 from pylegend._typing import (
     PyLegendSequence
 )
-from pylegend.core.tds.legend_api.frames.legend_api_input_tds_frame import LegendApiExecutableInputTdsFrame
+from pylegend.core.tds.legacy_api.frames.legacy_api_input_tds_frame import LegacyApiExecutableInputTdsFrame
 from pylegend.core.project_cooridnates import ProjectCoordinates
 from pylegend.core.request.legend_client import LegendClient
 from pylegend.extensions.tds.abstract.legend_service_input_frame import LegendServiceInputFrameAbstract
 
 
 __all__: PyLegendSequence[str] = [
-    "LegendApiLegendServiceInputFrame"
+    "LegacyApiLegendServiceInputFrame"
 ]
 
 
-class LegendApiLegendServiceInputFrame(LegendServiceInputFrameAbstract, LegendApiExecutableInputTdsFrame):
+class LegacyApiLegendServiceInputFrame(LegendServiceInputFrameAbstract, LegacyApiExecutableInputTdsFrame):
 
     def __init__(
             self,
@@ -35,12 +35,12 @@ class LegendApiLegendServiceInputFrame(LegendServiceInputFrameAbstract, LegendAp
             legend_client: LegendClient,
     ) -> None:
         LegendServiceInputFrameAbstract.__init__(self, pattern=pattern, project_coordinates=project_coordinates)
-        LegendApiExecutableInputTdsFrame.__init__(
+        LegacyApiExecutableInputTdsFrame.__init__(
             self,
             legend_client=legend_client,
             columns=legend_client.get_sql_string_schema(self.to_sql_query())
         )
-        LegendApiLegendServiceInputFrame.set_initialized(self, True)
+        LegacyApiLegendServiceInputFrame.set_initialized(self, True)
 
     def __str__(self) -> str:
-        return f"LegendApiLegendServiceInputFrame({'.'.join(self.get_pattern())})"
+        return f"LegacyApiLegendServiceInputFrame({'.'.join(self.get_pattern())})"

pylegend/extensions/tds/{legend_api/frames/legend_api_table_spec_input_frame.py → legacy_api/frames/legacy_api_table_spec_input_frame.py}

@@ -16,21 +16,21 @@ from pylegend._typing import (
     PyLegendList,
     PyLegendSequence
 )
-from pylegend.core.tds.legend_api.frames.legend_api_input_tds_frame import LegendApiNonExecutableInputTdsFrame
+from pylegend.core.tds.legacy_api.frames.legacy_api_input_tds_frame import LegacyApiNonExecutableInputTdsFrame
 from pylegend.core.tds.tds_column import TdsColumn
 from pylegend.extensions.tds.abstract.table_spec_input_frame import TableSpecInputFrameAbstract
 
 
 __all__: PyLegendSequence[str] = [
-    "LegendApiTableSpecInputFrame"
+    "LegacyApiTableSpecInputFrame"
 ]
 
 
-class LegendApiTableSpecInputFrame(TableSpecInputFrameAbstract, LegendApiNonExecutableInputTdsFrame):
+class LegacyApiTableSpecInputFrame(TableSpecInputFrameAbstract, LegacyApiNonExecutableInputTdsFrame):
 
     def __init__(self, table_name_parts: PyLegendList[str], columns: PyLegendSequence[TdsColumn]) -> None:
         TableSpecInputFrameAbstract.__init__(self, table_name_parts=table_name_parts)
-        LegendApiNonExecutableInputTdsFrame.__init__(self, columns=columns)
+        LegacyApiNonExecutableInputTdsFrame.__init__(self, columns=columns)
 
     def __str__(self) -> str:
-        return f"LegendApiTableSpecInputFrame({'.'.join(self.table.parts)})"
+        return f"LegacyApiTableSpecInputFrame({'.'.join(self.table.parts)})"