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

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):

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)