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

pylegend/core/tds/{legend_api/frames/functions/group_by_function.py → legacy_api/frames/functions/legacy_api_group_by_function.py}

@@ -12,12 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from datetime import date, datetime
 from pylegend._typing import (
     PyLegendList,
     PyLegendSequence,
     PyLegendTuple,
 )
-from pylegend.core.tds.legend_api.frames.legend_api_applied_function_tds_frame import LegendApiAppliedFunction
+from pylegend.core.language.shared.helpers import generate_pure_lambda, escape_column_name
+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,26 +29,26 @@ 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,
-    AggregateSpecification,
+    LegacyApiTdsRow,
+    LegacyApiAggregateSpecification,
     PyLegendPrimitive,
     create_primitive_collection,
     convert_literal_to_literal_expression,
 )
-from pylegend.core.tds.legend_api.frames.functions.function_helpers import tds_column_for_primitive
 
 
 __all__: PyLegendSequence[str] = [
-    "GroupByFunction"
+    "LegacyApiGroupByFunction"
 ]
 
 
-class GroupByFunction(LegendApiAppliedFunction):
-    __base_frame: LegendApiBaseTdsFrame
+class LegacyApiGroupByFunction(LegacyApiAppliedFunction):
+    __base_frame: LegacyApiBaseTdsFrame
     __grouping_columns: PyLegendList[str]
-    __aggregations: PyLegendList[AggregateSpecification]
+    __aggregations: PyLegendList[LegacyApiAggregateSpecification]
 
     @classmethod
     def name(cls) -> str:
@@ -53,9 +56,9 @@ class GroupByFunction(LegendApiAppliedFunction):
 
     def __init__(
             self,
-            base_frame: LegendApiBaseTdsFrame,
+            base_frame: LegacyApiBaseTdsFrame,
             grouping_columns: PyLegendList[str],
-            aggregations: PyLegendList[AggregateSpecification],
+            aggregations: PyLegendList[LegacyApiAggregateSpecification],
     ) -> None:
         self.__base_frame = base_frame
         self.__grouping_columns = grouping_columns
@@ -87,7 +90,7 @@ class GroupByFunction(LegendApiAppliedFunction):
 
         new_select_items = [y[1] for y in sorted(new_cols_with_index, key=lambda x: x[0])]
 
-        tds_row = TdsRow.from_tds_frame("frame", self.__base_frame)
+        tds_row = LegacyApiTdsRow.from_tds_frame("frame", self.__base_frame)
         for agg in self.__aggregations:
             map_result = agg.get_map_fn()(tds_row)
             collection = create_primitive_collection(map_result)
@@ -111,10 +114,34 @@ class GroupByFunction(LegendApiAppliedFunction):
         ]
         return new_query
 
-    def base_frame(self) -> LegendApiBaseTdsFrame:
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        group_strings = []
+        for col_name in self.__grouping_columns:
+            group_strings.append(escape_column_name(col_name))
+
+        agg_strings = []
+        tds_row = LegacyApiTdsRow.from_tds_frame("r", self.__base_frame)
+        for agg in self.__aggregations:
+            agg_name = escape_column_name(agg.get_name())
+            map_expr = agg.get_map_fn()(tds_row)
+            collection = create_primitive_collection(map_expr)
+            agg_expr = agg.get_aggregate_fn()(collection)
+            map_expr_string = (map_expr.to_pure_expression(config) if isinstance(map_expr, PyLegendPrimitive) else
+                               convert_literal_to_literal_expression(map_expr).to_pure_expression(config))
+            agg_expr_string = agg_expr.to_pure_expression(config).replace(map_expr_string, "$c")
+            agg_strings.append(f"{agg_name}:{generate_pure_lambda('r', map_expr_string)}:"
+                               f"{generate_pure_lambda('c', agg_expr_string)}")
+
+        return (f"{self.__base_frame.to_pure(config)}{config.separator(1)}" +
+                f"->groupBy({config.separator(2)}"
+                f"~[{', '.join(group_strings)}],{config.separator(2, True)}"
+                f"~[{', '.join(agg_strings)}]{config.separator(1)}"
+                f")")
+
+    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"]:
@@ -125,7 +152,7 @@ class GroupByFunction(LegendApiAppliedFunction):
                 if base_col.get_name() == c:
                     new_columns.append(base_col.copy())
 
-        tds_row = TdsRow.from_tds_frame("frame", self.__base_frame)
+        tds_row = LegacyApiTdsRow.from_tds_frame("frame", self.__base_frame)
         for agg in self.__aggregations:
             map_result = agg.get_map_fn()(tds_row)
             collection = create_primitive_collection(map_result)
@@ -159,7 +186,7 @@ class GroupByFunction(LegendApiAppliedFunction):
             raise ValueError("Found duplicate column names in grouping columns and aggregation columns. "
                              f"Grouping columns - {self.__grouping_columns}, Aggregation columns - {agg_cols}")
 
-        tds_row = TdsRow.from_tds_frame("frame", self.__base_frame)
+        tds_row = LegacyApiTdsRow.from_tds_frame("frame", self.__base_frame)
         index = 0
         for agg in self.__aggregations:
             map_fn_copy = agg.get_map_fn()  # For MyPy
@@ -176,7 +203,7 @@ class GroupByFunction(LegendApiAppliedFunction):
                     f"Error occurred while evaluating map function. Message: {str(e)}"
                 ) from e
 
-            if not isinstance(map_result, (int, float, bool, str, PyLegendPrimitive)):
+            if not isinstance(map_result, (int, float, bool, str, date, datetime, PyLegendPrimitive)):
                 raise ValueError(
                     f"AggregateSpecification at index {index} (0-indexed) incompatible. "
                     f"Map function returns non-primitive - {str(type(map_result))}"

pylegend/core/tds/{legend_api/frames/functions/head_function.py → legacy_api/frames/functions/legacy_api_head_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] = [
-    "HeadFunction"
+    "LegacyApiHeadFunction"
 ]
 
 
-class HeadFunction(LegendApiAppliedFunction):
-    __base_frame: LegendApiBaseTdsFrame
+class LegacyApiHeadFunction(LegacyApiAppliedFunction):
+    __base_frame: LegacyApiBaseTdsFrame
     __row_count: int
 
     @classmethod
     def name(cls) -> str:
         return "head"
 
-    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 HeadFunction(LegendApiAppliedFunction):
         new_query.limit = 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"->limit({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/join_by_columns_function.py → legacy_api/frames/functions/legacy_api_join_by_columns_function.py}

@@ -17,7 +17,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, extract_columns_for_subquery
 from pylegend.core.sql.metamodel import (
     QuerySpecification,
@@ -40,18 +40,20 @@ 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.legend_api.frames.legend_api_tds_frame import LegendApiTdsFrame
+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.tds.legacy_api.frames.legacy_api_tds_frame import LegacyApiTdsFrame
+from pylegend.core.language.shared.helpers import generate_pure_lambda, escape_column_name
 
 
 __all__: PyLegendSequence[str] = [
-    "JoinByColumnsFunction"
+    "LegacyApiJoinByColumnsFunction"
 ]
 
 
-class JoinByColumnsFunction(LegendApiAppliedFunction):
-    __base_frame: LegendApiBaseTdsFrame
-    __other_frame: LegendApiBaseTdsFrame
+class LegacyApiJoinByColumnsFunction(LegacyApiAppliedFunction):
+    __base_frame: LegacyApiBaseTdsFrame
+    __other_frame: LegacyApiBaseTdsFrame
     __column_names_self: PyLegendList[str]
     __column_names_other: PyLegendList[str]
     __join_type: str
@@ -62,15 +64,15 @@ class JoinByColumnsFunction(LegendApiAppliedFunction):
 
     def __init__(
             self,
-            base_frame: LegendApiBaseTdsFrame,
-            other_frame: LegendApiTdsFrame,
+            base_frame: LegacyApiBaseTdsFrame,
+            other_frame: LegacyApiTdsFrame,
             column_names_self: PyLegendList[str],
             column_names_other: PyLegendList[str],
             join_type: str
     ) -> None:
         self.__base_frame = base_frame
-        if not isinstance(other_frame, LegendApiBaseTdsFrame):
-            raise ValueError("Expected LegendApiBaseTdsFrame")  # pragma: no cover
+        if not isinstance(other_frame, LegacyApiBaseTdsFrame):
+            raise ValueError("Expected LegacyApiBaseTdsFrame")  # pragma: no cover
         self.__other_frame = other_frame
         self.__column_names_self = column_names_self
         self.__column_names_other = column_names_other
@@ -160,10 +162,35 @@ class JoinByColumnsFunction(LegendApiAppliedFunction):
         wrapped_join_query = create_sub_query(join_query, config, "root")
         return wrapped_join_query
 
-    def base_frame(self) -> LegendApiBaseTdsFrame:
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        common_join_cols = [x for x, y in zip(self.__column_names_self, self.__column_names_other) if x == y]
+        other_frame = (self.__other_frame if (len(common_join_cols) == 0) else
+                       self.__other_frame.rename_columns(common_join_cols, [c + "_gen_r" for c in common_join_cols]))
+        sub_expressions = []
+        for x, y in zip(self.__column_names_self, self.__column_names_other):
+            left = "$l." + escape_column_name(x)
+            y = (y + "_gen_r") if y in common_join_cols else y
+            right = "$r." + escape_column_name(y)
+            sub_expressions.append(f"({left} == {right})")
+
+        join_expr_string = " && ".join(sub_expressions)
+        join_kind = (
+            "INNER" if self.__join_type.lower() == 'inner' else
+            "LEFT" if self.__join_type.lower() in ('left_outer', 'leftouter') else
+            "RIGHT" if self.__join_type.lower() in ('right_outer', 'rightouter') else
+            "FULL"
+        )
+        return (f"{self.__base_frame.to_pure(config)}{config.separator(1)}" +
+                f"->join({config.separator(2)}"
+                f"{other_frame.to_pure(config.push_indent(2))},{config.separator(2, True)}"  # type: ignore
+                f"JoinKind.{join_kind},{config.separator(2, True)}"
+                f"{generate_pure_lambda('l, r', join_expr_string)}{config.separator(1)}"
+                f")")
+
+    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/join_function.py → legacy_api/frames/functions/legacy_api_join_function.py}

@@ -18,7 +18,7 @@ from pylegend._typing import (
     PyLegendUnion,
     PyLegendCallable,
 )
-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, extract_columns_for_subquery
 from pylegend.core.sql.metamodel import (
     QuerySpecification,
@@ -36,24 +36,28 @@ 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.legend_api.frames.legend_api_tds_frame import LegendApiTdsFrame
+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.tds.legacy_api.frames.legacy_api_tds_frame import LegacyApiTdsFrame
 from pylegend.core.language import (
     PyLegendBoolean,
-    TdsRow,
+    LegacyApiTdsRow,
     PyLegendBooleanLiteralExpression,
+    PyLegendPrimitive,
+    convert_literal_to_literal_expression,
 )
+from pylegend.core.language.shared.helpers import generate_pure_lambda
 
 
 __all__: PyLegendSequence[str] = [
-    "JoinFunction"
+    "LegacyApiJoinFunction"
 ]
 
 
-class JoinFunction(LegendApiAppliedFunction):
-    __base_frame: LegendApiBaseTdsFrame
-    __other_frame: LegendApiBaseTdsFrame
-    __join_condition: PyLegendCallable[[TdsRow, TdsRow], PyLegendUnion[bool, PyLegendBoolean]]
+class LegacyApiJoinFunction(LegacyApiAppliedFunction):
+    __base_frame: LegacyApiBaseTdsFrame
+    __other_frame: LegacyApiBaseTdsFrame
+    __join_condition: PyLegendCallable[[LegacyApiTdsRow, LegacyApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]]
     __join_type: str
 
     @classmethod
@@ -62,14 +66,14 @@ class JoinFunction(LegendApiAppliedFunction):
 
     def __init__(
             self,
-            base_frame: LegendApiBaseTdsFrame,
-            other_frame: LegendApiTdsFrame,
-            join_condition: PyLegendCallable[[TdsRow, TdsRow], PyLegendUnion[bool, PyLegendBoolean]],
+            base_frame: LegacyApiBaseTdsFrame,
+            other_frame: LegacyApiTdsFrame,
+            join_condition: PyLegendCallable[[LegacyApiTdsRow, LegacyApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]],
             join_type: str
     ) -> None:
         self.__base_frame = base_frame
-        if not isinstance(other_frame, LegendApiBaseTdsFrame):
-            raise ValueError("Expected LegendApiBaseTdsFrame")  # pragma: no cover
+        if not isinstance(other_frame, LegacyApiBaseTdsFrame):
+            raise ValueError("Expected LegacyApiBaseTdsFrame")  # pragma: no cover
         self.__other_frame = other_frame
         self.__join_condition = join_condition
         self.__join_type = join_type
@@ -86,8 +90,8 @@ class JoinFunction(LegendApiAppliedFunction):
             )
         )
 
-        left_row = TdsRow.from_tds_frame('left', self.__base_frame)
-        right_row = TdsRow.from_tds_frame('right', self.__other_frame)
+        left_row = LegacyApiTdsRow.from_tds_frame('left', self.__base_frame)
+        right_row = LegacyApiTdsRow.from_tds_frame('right', self.__other_frame)
 
         join_expr = self.__join_condition(left_row, right_row)
         if isinstance(join_expr, bool):
@@ -142,10 +146,30 @@ class JoinFunction(LegendApiAppliedFunction):
         wrapped_join_query = create_sub_query(join_query, config, "root")
         return wrapped_join_query
 
-    def base_frame(self) -> LegendApiBaseTdsFrame:
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        left_row = LegacyApiTdsRow.from_tds_frame("l", self.__base_frame)
+        right_row = LegacyApiTdsRow.from_tds_frame("r", self.__other_frame)
+        join_expr = self.__join_condition(left_row, right_row)
+        join_expr_string = (join_expr.to_pure_expression(config.push_indent(2))
+                            if isinstance(join_expr, PyLegendPrimitive) else
+                            convert_literal_to_literal_expression(join_expr).to_pure_expression(config.push_indent(2)))
+        join_kind = (
+            "INNER" if self.__join_type.lower() == 'inner' else
+            "LEFT" if self.__join_type.lower() in ('left_outer', 'leftouter') else
+            "RIGHT" if self.__join_type.lower() in ('right_outer', 'rightouter') else
+            "FULL"
+        )
+        return (f"{self.__base_frame.to_pure(config)}{config.separator(1)}" +
+                f"->join({config.separator(2)}"
+                f"{self.__other_frame.to_pure(config.push_indent(2))},{config.separator(2, True)}"
+                f"JoinKind.{join_kind},{config.separator(2, True)}"
+                f"{generate_pure_lambda('l, r', join_expr_string)}{config.separator(1)}"
+                f")")
+
+    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"]:
@@ -159,8 +183,8 @@ class JoinFunction(LegendApiAppliedFunction):
         if not isinstance(copy, type(lambda x: 0)) or (copy.__code__.co_argcount != 2):
             raise TypeError("Join condition function should be a lambda which takes two arguments (TDSRow, TDSRow)")
 
-        left_row = TdsRow.from_tds_frame("left", self.__base_frame)
-        right_row = TdsRow.from_tds_frame("right", self.__other_frame)
+        left_row = LegacyApiTdsRow.from_tds_frame("left", self.__base_frame)
+        right_row = LegacyApiTdsRow.from_tds_frame("right", self.__other_frame)
 
         try:
             result = self.__join_condition(left_row, right_row)

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