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

pylegend/core/request/auth.py

@@ -15,6 +15,7 @@
 from abc import ABCMeta, abstractmethod
 
 from requests import PreparedRequest
+from requests.cookies import create_cookie
 
 from pylegend._typing import (
     PyLegendSequence,
@@ -27,7 +28,8 @@ from requests.auth import AuthBase
 __all__: PyLegendSequence[str] = [
     "AuthScheme",
     "LocalhostEmptyAuthScheme",
-    "HeaderTokenAuthScheme"
+    "HeaderTokenAuthScheme",
+    "CookieAuthScheme",
 ]
 
 
@@ -83,3 +85,55 @@ class HeaderTokenAuthScheme(AuthScheme):
 
     def get_auth_base(self) -> PyLegendOptional[AuthBase]:
         return HeaderTokenAuth(self.__header_name, self.__token_provider, self.__query_params)
+
+
+class CookieAuth(AuthBase):
+    __cookie_name: str
+    __cookie_provider: PyLegendCallable[[], str]
+    __query_params: PyLegendOptional[PyLegendDict[str, str]]
+
+    def __init__(  # type: ignore
+            self,
+            cookie_name: str,
+            cookie_provider: PyLegendCallable[[], str],
+            query_params: PyLegendOptional[PyLegendDict[str, str]] = None,
+            **extra_cookie_params
+    ) -> None:
+        self.__cookie_name = cookie_name
+        self.__cookie_provider = cookie_provider
+        self.__query_params = query_params
+        self.__extra_cookie_params = extra_cookie_params
+
+    def __call__(self, r: PreparedRequest) -> PreparedRequest:
+        if self.__query_params:
+            r.prepare_url(r.url, self.__query_params)
+        r.headers.pop("Cookie", None)
+        new_cookie = create_cookie(  # type: ignore
+            name=self.__cookie_name,
+            value=self.__cookie_provider(),
+            **self.__extra_cookie_params
+        )
+        r._cookies.set_cookie(new_cookie)  # type: ignore
+        r.prepare_cookies(r._cookies)  # type: ignore
+        return r
+
+
+class CookieAuthScheme(AuthScheme):
+    __cookie_name: str
+    __cookie_provider: PyLegendCallable[[], str]
+    __query_params: PyLegendOptional[PyLegendDict[str, str]]
+
+    def __init__(  # type: ignore
+            self,
+            cookie_name: str,
+            cookie_provider: PyLegendCallable[[], str],
+            query_params: PyLegendOptional[PyLegendDict[str, str]] = None,
+            **extra_cookie_params
+    ) -> None:
+        self.__cookie_name = cookie_name
+        self.__cookie_provider = cookie_provider
+        self.__query_params = query_params
+        self.__extra_cookie_params = extra_cookie_params
+
+    def get_auth_base(self) -> PyLegendOptional[AuthBase]:
+        return CookieAuth(self.__cookie_name, self.__cookie_provider, self.__query_params, **self.__extra_cookie_params)

pylegend/core/request/legend_client.py

@@ -77,6 +77,38 @@ class LegendClient(ServiceClient):
         ).iter_content(chunk_size=chunk_size)
         return ResponseReader(iter_content)
 
+    def parse_model(
+            self,
+            model_code: str,
+            return_source_information: bool = False
+    ) -> str:
+        response = super()._execute_service(
+            method=RequestMethod.POST,
+            path="pure/v1/grammar/grammarToJson/model",
+            data=model_code,
+            headers={"Content-Type": "text/plain"},
+            query_params=[("returnSourceInformation", "true" if return_source_information else "false")]
+        )
+        return response.text
+
+    def compile_model(
+            self,
+            model_json: str
+    ) -> None:
+        super()._execute_service(
+            method=RequestMethod.POST,
+            path="pure/v1/compilation/compile",
+            data=model_json,
+            headers={"Content-Type": "application/json"}
+        )
+
+    def parse_and_compile_model(
+            self,
+            model_code: str
+    ) -> None:
+        parse_response = self.parse_model(model_code)
+        self.compile_model(parse_response)
+
     def __eq__(self, other: 'object') -> bool:
         if self is other:
             return True

pylegend/core/sql/metamodel_extension.py

@@ -19,6 +19,7 @@ from pylegend._typing import (
 )
 from pylegend.core.sql.metamodel import (
     Expression,
+    Window,
 )
 
 __all__: PyLegendSequence[str] = [
@@ -78,6 +79,8 @@ __all__: PyLegendSequence[str] = [
     "MinuteExpression",
     "SecondExpression",
     "EpochExpression",
+    "WindowExpression",
+    "ConstantExpression",
 ]
 
 
@@ -717,3 +720,28 @@ class EpochExpression(Expression):
     ) -> None:
         super().__init__(_type="epochExpression")
         self.value = value
+
+
+class WindowExpression(Expression):
+    nested: "Expression"
+    window: "Window"
+
+    def __init__(
+        self,
+        nested: "Expression",
+        window: "Window",
+    ) -> None:
+        super().__init__(_type="windowExpression")
+        self.nested = nested
+        self.window = window
+
+
+class ConstantExpression(Expression):
+    name: str
+
+    def __init__(
+        self,
+        name: str
+    ) -> None:
+        super().__init__(_type="constantExpression")
+        self.name = name

pylegend/core/tds/abstract/__init__.py

@@ -0,0 +1,13 @@
+# 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.

pylegend/core/tds/abstract/frames/__init__.py

@@ -0,0 +1,13 @@
+# 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.

pylegend/core/tds/{legend_api/frames/legend_api_applied_function_tds_frame.py → abstract/frames/applied_function_tds_frame.py}

@@ -15,21 +15,21 @@
 from abc import ABCMeta, abstractmethod
 from pylegend._typing import (
     PyLegendSequence,
-    PyLegendList,
 )
 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.legend_api.frames.legend_api_base_tds_frame import LegendApiBaseTdsFrame
+from pylegend.core.tds.tds_frame import FrameToPureConfig
+from pylegend.core.tds.abstract.frames.base_tds_frame import BaseTdsFrame
 
 
 __all__: PyLegendSequence[str] = [
-    "LegendApiAppliedFunctionTdsFrame",
-    "LegendApiAppliedFunction",
+    "AppliedFunctionTdsFrame",
+    "AppliedFunction",
 ]
 
 
-class LegendApiAppliedFunction(metaclass=ABCMeta):
+class AppliedFunction(metaclass=ABCMeta):
     @classmethod
     @abstractmethod
     def name(cls) -> str:
@@ -39,16 +39,19 @@ class LegendApiAppliedFunction(metaclass=ABCMeta):
     def to_sql(self, config: FrameToSqlConfig) -> QuerySpecification:
         pass  # pragma: no cover
 
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        raise RuntimeError("PURE generation not supported for '" + self.name() + "' function")
+
     @abstractmethod
-    def base_frame(self) -> LegendApiBaseTdsFrame:
+    def base_frame(self) -> BaseTdsFrame:
         pass  # pragma: no cover
 
     @abstractmethod
-    def tds_frame_parameters(self) -> PyLegendList["LegendApiBaseTdsFrame"]:
+    def tds_frame_parameters(self) -> PyLegendSequence[BaseTdsFrame]:
         pass  # pragma: no cover
 
     @abstractmethod
-    def calculate_columns(self) -> PyLegendSequence["TdsColumn"]:
+    def calculate_columns(self) -> PyLegendSequence[TdsColumn]:
         pass  # pragma: no cover
 
     @abstractmethod
@@ -56,10 +59,10 @@ class LegendApiAppliedFunction(metaclass=ABCMeta):
         pass  # pragma: no cover
 
 
-class LegendApiAppliedFunctionTdsFrame(LegendApiBaseTdsFrame):
-    __applied_function: LegendApiAppliedFunction
+class AppliedFunctionTdsFrame(BaseTdsFrame, metaclass=ABCMeta):
+    __applied_function: AppliedFunction
 
-    def __init__(self, applied_function: LegendApiAppliedFunction):
+    def __init__(self, applied_function: AppliedFunction):
         applied_function.validate()
         super().__init__(columns=applied_function.calculate_columns())
         self.__applied_function = applied_function
@@ -67,9 +70,12 @@ class LegendApiAppliedFunctionTdsFrame(LegendApiBaseTdsFrame):
     def to_sql_query_object(self, config: FrameToSqlConfig) -> QuerySpecification:
         return self.__applied_function.to_sql(config)
 
-    def get_all_tds_frames(self) -> PyLegendList["LegendApiBaseTdsFrame"]:
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        return self.__applied_function.to_pure(config)
+
+    def get_all_tds_frames(self) -> PyLegendSequence[BaseTdsFrame]:
         return [
             y
-            for x in [self.__applied_function.base_frame()] + self.__applied_function.tds_frame_parameters()
+            for x in [self.__applied_function.base_frame()] + list(self.__applied_function.tds_frame_parameters())
             for y in x.get_all_tds_frames()
         ] + [self]

pylegend/core/tds/abstract/frames/base_tds_frame.py

@@ -0,0 +1,125 @@
+# 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
+import pandas as pd
+from pylegend._typing import (
+    PyLegendSequence,
+    PyLegendTypeVar,
+    PyLegendOptional,
+)
+from pylegend.core.sql.metamodel import QuerySpecification
+from pylegend.core.database.sql_to_string import (
+    SqlToStringConfig,
+    SqlToStringFormat
+)
+from pylegend.core.tds.tds_column import TdsColumn
+from pylegend.core.tds.tds_frame import FrameToSqlConfig, PyLegendTdsFrame
+from pylegend.core.tds.tds_frame import FrameToPureConfig
+from pylegend.core.tds.result_handler import (
+    ResultHandler,
+    ToStringResultHandler,
+)
+from pylegend.extensions.tds.result_handler import (
+    ToPandasDfResultHandler,
+    PandasDfReadConfig,
+)
+__all__: PyLegendSequence[str] = [
+    "BaseTdsFrame"
+]
+
+R = PyLegendTypeVar('R')
+
+
+class BaseTdsFrame(PyLegendTdsFrame, metaclass=ABCMeta):
+    __columns: PyLegendSequence[TdsColumn]
+
+    def __init__(self, columns: PyLegendSequence[TdsColumn]) -> None:
+        col_names = [c.get_name() for c in columns]
+        if len(col_names) != len(set(col_names)):
+            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]
+
+    def columns(self) -> PyLegendSequence[TdsColumn]:
+        return [c.copy() for c in self.__columns]
+
+    @abstractmethod
+    def to_sql_query_object(self, config: FrameToSqlConfig) -> QuerySpecification:
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def get_all_tds_frames(self) -> PyLegendSequence["BaseTdsFrame"]:
+        pass  # pragma: no cover
+
+    def to_sql_query(self, config: FrameToSqlConfig = FrameToSqlConfig()) -> str:
+        query = self.to_sql_query_object(config)
+        sql_to_string_config = SqlToStringConfig(format_=SqlToStringFormat(pretty=config.pretty))
+        return config.sql_to_string_generator().generate_sql_string(query, sql_to_string_config)
+
+    @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)
+
+    def execute_frame(
+            self,
+            result_handler: ResultHandler[R],
+            chunk_size: PyLegendOptional[int] = None
+    ) -> R:
+        from pylegend.core.tds.abstract.frames.input_tds_frame import InputTdsFrame, ExecutableInputTdsFrame
+
+        tds_frames = self.get_all_tds_frames()
+        input_frames = [x for x in tds_frames if isinstance(x, InputTdsFrame)]
+
+        non_exec_frames = [x for x in input_frames if not isinstance(x, ExecutableInputTdsFrame)]
+        if non_exec_frames:
+            raise ValueError(
+                "Cannot execute frame as its built on top of non-executable input frames: [" +
+                (", ".join([str(f) for f in non_exec_frames]) + "]")
+            )
+
+        exec_frames = [x for x in input_frames if isinstance(x, ExecutableInputTdsFrame)]
+
+        all_legend_clients = []
+        for e in exec_frames:
+            c = e.get_legend_client()
+            if c not in all_legend_clients:
+                all_legend_clients.append(c)
+        if len(all_legend_clients) > 1:
+            raise ValueError(
+                "Found tds frames with multiple legend_clients (which is not supported): [" +
+                (", ".join([str(f) for f in all_legend_clients]) + "]")
+            )
+        legend_client = all_legend_clients[0]
+        result = legend_client.execute_sql_string(self.to_sql_query(), chunk_size=chunk_size)
+        return result_handler.handle_result(self, result)
+
+    def execute_frame_to_string(
+            self,
+            chunk_size: PyLegendOptional[int] = None
+    ) -> str:
+        return self.execute_frame(ToStringResultHandler(), chunk_size)
+
+    def execute_frame_to_pandas_df(
+            self,
+            chunk_size: PyLegendOptional[int] = None,
+            pandas_df_read_config: PandasDfReadConfig = PandasDfReadConfig()
+    ) -> pd.DataFrame:
+        return self.execute_frame(
+            ToPandasDfResultHandler(pandas_df_read_config),
+            chunk_size
+        )

pylegend/core/tds/{legend_api/frames/legend_api_input_tds_frame.py → abstract/frames/input_tds_frame.py}

@@ -1,4 +1,4 @@
-# Copyright 2023 Goldman Sachs
+# 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.
@@ -15,30 +15,28 @@
 from abc import ABCMeta
 from pylegend._typing import (
     PyLegendSequence,
-    PyLegendList
 )
 from pylegend.core.tds.tds_column import TdsColumn
-from pylegend.core.tds.legend_api.frames.legend_api_base_tds_frame import LegendApiBaseTdsFrame
+from pylegend.core.tds.abstract.frames.base_tds_frame import BaseTdsFrame
 from pylegend.core.request.legend_client import LegendClient
 
 
 __all__: PyLegendSequence[str] = [
-    "LegendApiExecutableInputTdsFrame",
-    "LegendApiNonExecutableInputTdsFrame",
-    "LegendApiInputTdsFrame"
+    "ExecutableInputTdsFrame",
+    "NonExecutableInputTdsFrame",
+    "InputTdsFrame"
 ]
 
 
-class LegendApiInputTdsFrame(LegendApiBaseTdsFrame, metaclass=ABCMeta):
-
+class InputTdsFrame(BaseTdsFrame, metaclass=ABCMeta):
     def __init__(self, columns: PyLegendSequence[TdsColumn]) -> None:
         super().__init__(columns=columns)
 
-    def get_all_tds_frames(self) -> PyLegendList["LegendApiBaseTdsFrame"]:
+    def get_all_tds_frames(self) -> PyLegendSequence["BaseTdsFrame"]:
         return [self]
 
 
-class LegendApiExecutableInputTdsFrame(LegendApiInputTdsFrame, metaclass=ABCMeta):
+class ExecutableInputTdsFrame(InputTdsFrame, metaclass=ABCMeta):
     __legend_client: LegendClient
 
     def __init__(self, legend_client: LegendClient, columns: PyLegendSequence[TdsColumn]) -> None:
@@ -49,7 +47,6 @@ class LegendApiExecutableInputTdsFrame(LegendApiInputTdsFrame, metaclass=ABCMeta
         return self.__legend_client
 
 
-class LegendApiNonExecutableInputTdsFrame(LegendApiInputTdsFrame, metaclass=ABCMeta):
-
+class NonExecutableInputTdsFrame(InputTdsFrame, metaclass=ABCMeta):
     def __init__(self, columns: PyLegendSequence[TdsColumn]) -> None:
         super().__init__(columns=columns)

pylegend/core/tds/{legend_api/frames/functions → abstract}/function_helpers.py

@@ -1,4 +1,4 @@
-# Copyright 2023 Goldman Sachs
+# 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.

pylegend/core/tds/{legend_api/frames/functions/concatenate_function.py → legacy_api/frames/functions/legacy_api_concatenate_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.sql.metamodel import (
     QuerySpecification,
     Union,
@@ -28,29 +28,31 @@ from pylegend.core.sql.metamodel import (
     TableSubquery,
     Query,
 )
+from pylegend.core.tds.sql_query_helpers import create_sub_query
 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_tds_frame import LegendApiTdsFrame
-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_tds_frame import LegacyApiTdsFrame
+from pylegend.core.tds.legacy_api.frames.legacy_api_base_tds_frame import LegacyApiBaseTdsFrame
 
 
 __all__: PyLegendSequence[str] = [
-    "ConcatenateFunction"
+    "LegacyApiConcatenateFunction"
 ]
 
 
-class ConcatenateFunction(LegendApiAppliedFunction):
-    __base_frame: LegendApiBaseTdsFrame
-    __other_frame: LegendApiBaseTdsFrame
+class LegacyApiConcatenateFunction(LegacyApiAppliedFunction):
+    __base_frame: LegacyApiBaseTdsFrame
+    __other_frame: LegacyApiBaseTdsFrame
 
     @classmethod
     def name(cls) -> str:
         return "concatenate"
 
-    def __init__(self, base_frame: LegendApiBaseTdsFrame, other: LegendApiTdsFrame) -> None:
+    def __init__(self, base_frame: LegacyApiBaseTdsFrame, other: LegacyApiTdsFrame) -> None:
         self.__base_frame = base_frame
-        if not isinstance(other, LegendApiBaseTdsFrame):
-            raise ValueError("Expected LegendApiBaseTdsFrame")  # pragma: no cover
+        if not isinstance(other, LegacyApiBaseTdsFrame):
+            raise ValueError("Expected LegacyApiBaseTdsFrame")  # pragma: no cover
         self.__other_frame = other
 
     def to_sql(self, config: FrameToSqlConfig) -> QuerySpecification:
@@ -76,7 +78,11 @@ class ConcatenateFunction(LegendApiAppliedFunction):
                 AliasedRelation(
                     relation=TableSubquery(
                         query=Query(
-                            queryBody=Union(left=base_query, right=other_query, distinct=False),
+                            queryBody=Union(
+                                left=create_sub_query(base_query, config, "left"),
+                                right=create_sub_query(other_query, config, "right"),
+                                distinct=False
+                            ),
                             limit=None, offset=None, orderBy=[]
                         )
                     ),
@@ -92,10 +98,16 @@ class ConcatenateFunction(LegendApiAppliedFunction):
             offset=None
         )
 
-    def base_frame(self) -> LegendApiBaseTdsFrame:
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        return (f"{self.__base_frame.to_pure(config)}{config.separator(1)}"
+                f"->concatenate({config.separator(2)}"
+                f"{self.__other_frame.to_pure(config.push_indent(2))}"
+                f"{config.separator(1)})")
+
+    def base_frame(self) -> LegacyApiBaseTdsFrame:
         return self.__base_frame
 
-    def tds_frame_parameters(self) -> PyLegendList["LegendApiBaseTdsFrame"]:
+    def tds_frame_parameters(self) -> PyLegendList["LegacyApiBaseTdsFrame"]:
         return [self.__other_frame]
 
     def calculate_columns(self) -> PyLegendSequence["TdsColumn"]:

pylegend/core/tds/{legend_api/frames/functions/distinct_function.py → legacy_api/frames/functions/legacy_api_distinct_function.py}

@@ -16,29 +16,30 @@ 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,
 )
 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] = [
-    "DistinctFunction"
+    "LegacyApiDistinctFunction"
 ]
 
 
-class DistinctFunction(LegendApiAppliedFunction):
-    __base_frame: LegendApiBaseTdsFrame
+class LegacyApiDistinctFunction(LegacyApiAppliedFunction):
+    __base_frame: LegacyApiBaseTdsFrame
 
     @classmethod
     def name(cls) -> str:
         return "distinct"
 
-    def __init__(self, base_frame: LegendApiBaseTdsFrame) -> None:
+    def __init__(self, base_frame: LegacyApiBaseTdsFrame) -> None:
         self.__base_frame = base_frame
 
     def to_sql(self, config: FrameToSqlConfig) -> QuerySpecification:
@@ -51,10 +52,14 @@ class DistinctFunction(LegendApiAppliedFunction):
         new_query.select.distinct = True
         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"->distinct()")
+
+    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/drop_function.py → legacy_api/frames/functions/legacy_api_drop_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,23 +24,24 @@ 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] = [
-    "DropFunction"
+    "LegacyApiDropFunction"
 ]
 
 
-class DropFunction(LegendApiAppliedFunction):
-    __base_frame: LegendApiBaseTdsFrame
+class LegacyApiDropFunction(LegacyApiAppliedFunction):
+    __base_frame: LegacyApiBaseTdsFrame
     __row_count: int
 
     @classmethod
     def name(cls) -> str:
         return "drop"
 
-    def __init__(self, base_frame: LegendApiBaseTdsFrame, row_count: int) -> None:
+    def __init__(self, base_frame: LegacyApiBaseTdsFrame, row_count: int) -> None:
         self.__base_frame = base_frame
         self.__row_count = row_count
 
@@ -54,10 +55,14 @@ class DropFunction(LegendApiAppliedFunction):
         new_query.offset = LongLiteral(value=self.__row_count)
         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"->drop({self.__row_count})")
+
+    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"]: