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

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"]:

pylegend/core/tds/{legend_api/frames/functions/extend_function.py → legacy_api/frames/functions/legacy_api_extend_function.py}

@@ -18,7 +18,8 @@ from pylegend._typing import (
     PyLegendSequence,
     PyLegendCallable,
 )
-from pylegend.core.tds.legend_api.frames.legend_api_applied_function_tds_frame import LegendApiAppliedFunction
+from pylegend.core.tds.abstract.function_helpers import tds_column_for_primitive
+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 +27,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
 from pylegend.core.language import (
-    TdsRow,
+    LegacyApiTdsRow,
     PyLegendPrimitive,
     PyLegendPrimitiveOrPythonPrimitive,
     convert_literal_to_literal_expression,
 )
-from pylegend.core.tds.legend_api.frames.functions.function_helpers import tds_column_for_primitive
+from pylegend.core.language.shared.helpers import generate_pure_lambda, escape_column_name
 
 __all__: PyLegendSequence[str] = [
-    "ExtendFunction"
+    "LegacyApiExtendFunction"
 ]
 
 
-class ExtendFunction(LegendApiAppliedFunction):
-    __base_frame: LegendApiBaseTdsFrame
-    __functions_list: PyLegendList[PyLegendCallable[[TdsRow], PyLegendPrimitiveOrPythonPrimitive]]
+class LegacyApiExtendFunction(LegacyApiAppliedFunction):
+    __base_frame: LegacyApiBaseTdsFrame
+    __functions_list: PyLegendList[PyLegendCallable[[LegacyApiTdsRow], PyLegendPrimitiveOrPythonPrimitive]]
     __column_names_list: PyLegendList[str]
 
     @classmethod
@@ -51,8 +53,8 @@ class ExtendFunction(LegendApiAppliedFunction):
 
     def __init__(
             self,
-            base_frame: LegendApiBaseTdsFrame,
-            functions_list: PyLegendList[PyLegendCallable[[TdsRow], PyLegendPrimitiveOrPythonPrimitive]],
+            base_frame: LegacyApiBaseTdsFrame,
+            functions_list: PyLegendList[PyLegendCallable[[LegacyApiTdsRow], PyLegendPrimitiveOrPythonPrimitive]],
             column_names_list: PyLegendList[str]
     ) -> None:
         self.__base_frame = base_frame
@@ -69,7 +71,7 @@ class ExtendFunction(LegendApiAppliedFunction):
             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 (func, name) in zip(self.__functions_list, self.__column_names_list):
             col_expr = func(tds_row)
 
@@ -87,16 +89,34 @@ class ExtendFunction(LegendApiAppliedFunction):
 
         return new_query
 
-    def base_frame(self) -> LegendApiBaseTdsFrame:
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        tds_row = LegacyApiTdsRow.from_tds_frame("r", self.__base_frame)
+        rendered_columns = []
+        for (func, col_name) in zip(self.__functions_list, self.__column_names_list):
+            col_expr = func(tds_row)
+            escaped_col_name = escape_column_name(col_name)
+            pure_expr = (col_expr.to_pure_expression(config) if isinstance(col_expr, PyLegendPrimitive) else
+                         convert_literal_to_literal_expression(col_expr).to_pure_expression(config))
+            rendered_columns.append(f"{escaped_col_name}:{generate_pure_lambda('r', pure_expr)}")
+
+        return (f"{self.__base_frame.to_pure(config)}{config.separator(1)}" +
+                (
+                    (f"->extend(~{rendered_columns[0]})") if len(rendered_columns) == 1 else
+                    (f"->extend(~[{config.separator(2)}"
+                     f"{(',' + config.separator(2, True)).join(rendered_columns)}"
+                     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 []
 
     def calculate_columns(self) -> PyLegendSequence["TdsColumn"]:
         new_columns = [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 (func, name) in zip(self.__functions_list, self.__column_names_list):
             result = func(tds_row)
             new_columns.append(tds_column_for_primitive(name, result))
@@ -111,7 +131,7 @@ class ExtendFunction(LegendApiAppliedFunction):
                 f"Column names: {len(self.__column_names_list)}"
             )
 
-        tds_row = TdsRow.from_tds_frame("frame", self.__base_frame)
+        tds_row = LegacyApiTdsRow.from_tds_frame("frame", self.__base_frame)
         index = 0
         for (func, name) in zip(self.__functions_list, self.__column_names_list):
             copy = func  # For MyPy
@@ -134,7 +154,7 @@ class ExtendFunction(LegendApiAppliedFunction):
                     f"Error occurred while evaluating. Message: {str(e)}"
                 ) from e
 
-            if not isinstance(result, (int, float, bool, str, PyLegendPrimitive)):
+            if not isinstance(result, (int, float, bool, str, date, datetime, PyLegendPrimitive)):
                 raise ValueError(
                     f"Extend function at index {index} (0-indexed) incompatible. "
                     f"Returns non-primitive - {str(type(result))}"

pylegend/core/tds/{legend_api/frames/functions/filter_function.py → legacy_api/frames/functions/legacy_api_filter_function.py}

@@ -18,7 +18,7 @@ from pylegend._typing import (
     PyLegendCallable,
     PyLegendUnion,
 )
-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,
@@ -27,21 +27,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 import (
-    TdsRow,
+    LegacyApiTdsRow,
     PyLegendBoolean,
     PyLegendBooleanLiteralExpression,
+    PyLegendPrimitive,
+    convert_literal_to_literal_expression,
 )
+from pylegend.core.language.shared.helpers import generate_pure_lambda
 
 __all__: PyLegendSequence[str] = [
-    "FilterFunction"
+    "LegacyApiFilterFunction"
 ]
 
 
-class FilterFunction(LegendApiAppliedFunction):
-    __base_frame: LegendApiBaseTdsFrame
-    __filter_function: PyLegendCallable[[TdsRow], PyLegendUnion[bool, PyLegendBoolean]]
+class LegacyApiFilterFunction(LegacyApiAppliedFunction):
+    __base_frame: LegacyApiBaseTdsFrame
+    __filter_function: PyLegendCallable[[LegacyApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]]
 
     @classmethod
     def name(cls) -> str:
@@ -49,8 +53,8 @@ class FilterFunction(LegendApiAppliedFunction):
 
     def __init__(
             self,
-            base_frame: LegendApiBaseTdsFrame,
-            filter_function: PyLegendCallable[[TdsRow], PyLegendUnion[bool, PyLegendBoolean]]
+            base_frame: LegacyApiBaseTdsFrame,
+            filter_function: PyLegendCallable[[LegacyApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]]
     ) -> None:
         self.__base_frame = base_frame
         self.__filter_function = filter_function
@@ -64,7 +68,7 @@ class FilterFunction(LegendApiAppliedFunction):
             copy_query(base_query)
         )
 
-        tds_row = TdsRow.from_tds_frame("frame", self.__base_frame)
+        tds_row = LegacyApiTdsRow.from_tds_frame("frame", self.__base_frame)
         filter_expr = self.__filter_function(tds_row)
         if isinstance(filter_expr, bool):
             filter_expr = PyLegendBoolean(PyLegendBooleanLiteralExpression(filter_expr))
@@ -80,17 +84,25 @@ class FilterFunction(LegendApiAppliedFunction):
 
         return new_query
 
-    def base_frame(self) -> LegendApiBaseTdsFrame:
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        tds_row = LegacyApiTdsRow.from_tds_frame("r", self.__base_frame)
+        filter_expr = self.__filter_function(tds_row)
+        filter_expr_string = (filter_expr.to_pure_expression(config) if isinstance(filter_expr, PyLegendPrimitive) else
+                              convert_literal_to_literal_expression(filter_expr).to_pure_expression(config))
+        return (f"{self.__base_frame.to_pure(config)}{config.separator(1)}" +
+                f"->filter({generate_pure_lambda('r', filter_expr_string)})")
+
+    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"]:
         return [c.copy() for c in self.__base_frame.columns()]
 
     def validate(self) -> bool:
-        tds_row = TdsRow.from_tds_frame("frame", self.__base_frame)
+        tds_row = LegacyApiTdsRow.from_tds_frame("frame", self.__base_frame)
 
         copy = self.__filter_function  # For MyPy
         if not isinstance(copy, type(lambda x: 0)) or (copy.__code__.co_argcount != 1):