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

pylegend/core/tds/legendql_api/frames/functions/legendql_api_project_function.py

@@ -0,0 +1,169 @@
+# 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 datetime import date, datetime
+from pylegend._typing import (
+    PyLegendList,
+    PyLegendSequence,
+    PyLegendCallable,
+    PyLegendUnion,
+    PyLegendTuple,
+)
+from pylegend.core.language.legendql_api.legendql_api_tds_row import LegendQLApiTdsRow
+from pylegend.core.tds.legendql_api.frames.legendql_api_applied_function_tds_frame import LegendQLApiAppliedFunction
+from pylegend.core.tds.sql_query_helpers import create_sub_query
+from pylegend.core.sql.metamodel import (
+    QuerySpecification,
+    SingleColumn,
+    SelectItem,
+)
+from pylegend.core.tds.tds_column import TdsColumn
+from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.core.tds.tds_frame import FrameToPureConfig
+from pylegend.core.tds.legendql_api.frames.legendql_api_base_tds_frame import LegendQLApiBaseTdsFrame
+from pylegend.core.language import (
+    PyLegendPrimitive,
+    PyLegendPrimitiveOrPythonPrimitive,
+    convert_literal_to_literal_expression,
+)
+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
+
+__all__: PyLegendSequence[str] = [
+    "LegendQLApiProjectFunction"
+]
+
+
+class LegendQLApiProjectFunction(LegendQLApiAppliedFunction):
+    __base_frame: LegendQLApiBaseTdsFrame
+    __new_column_expressions: PyLegendList[PyLegendTuple[str, PyLegendPrimitiveOrPythonPrimitive]]
+
+    @classmethod
+    def name(cls) -> str:
+        return "project"
+
+    def __init__(
+            self,
+            base_frame: LegendQLApiBaseTdsFrame,
+            project_columns: PyLegendUnion[
+                PyLegendTuple[
+                    str,
+                    PyLegendCallable[[LegendQLApiTdsRow], PyLegendPrimitiveOrPythonPrimitive]
+                ],
+                PyLegendList[
+                    PyLegendTuple[
+                        str,
+                        PyLegendCallable[[LegendQLApiTdsRow], PyLegendPrimitiveOrPythonPrimitive]
+                    ]
+                ]
+            ]
+    ) -> None:
+        self.__base_frame = base_frame
+        col_expressions: PyLegendList[PyLegendTuple[str, PyLegendPrimitiveOrPythonPrimitive]] = []
+        tds_row = LegendQLApiTdsRow.from_tds_frame("r", self.__base_frame)
+        for (i, project_col) in enumerate(project_columns if isinstance(project_columns, list) else [project_columns]):
+            if isinstance(project_col, tuple) and (len(project_col) == 2):
+                if not isinstance(project_col[0], str):
+                    raise TypeError(
+                        "'project' function project_columns argument incompatible. "
+                        "First element in an project tuple should be a string (new column name). "
+                        "E.g - ('new col', lambda r: r.c1 + 1). "
+                        f"Element at index {i} (0-indexed) is incompatible"
+                    )
+                if not isinstance(project_col[1], type(lambda x: 0)) or (project_col[1].__code__.co_argcount != 1):
+                    raise TypeError(
+                        "'project' function project_columns argument incompatible. "
+                        "Second element in an project tuple should be a lambda function which takes one argument "
+                        "(LegendQLApiTdsRow) E.g - ('new col', lambda r: r.c1 + 1)."
+                        f"Element at index {i} (0-indexed) is incompatible"
+                    )
+                try:
+                    result = project_col[1](tds_row)
+                except Exception as e:
+                    raise RuntimeError(
+                        "'project' function project_columns argument incompatible. "
+                        f"Error occurred while evaluating project lambda at index {i} (0-indexed). Message: " + str(e)
+                    ) from e
+
+                if not isinstance(result, (int, float, bool, str, date, datetime, PyLegendPrimitive)):
+                    raise TypeError(
+                        "'project' function project_columns argument incompatible. "
+                        f"Project lambda at index {i} (0-indexed) returns non-primitive - {str(type(result))}"
+                    )
+                col_expressions.append((project_col[0], result))
+            else:
+                raise TypeError(
+                    "'project' function project_columns argument should be a list of tuples with two elements - "
+                    "first element being a string (new column name), second element being a lambda "
+                    "function which takes one argument (LegendQLApiTdsRow) "
+                    "E.g - [('new col1', lambda r: r.c1 + 1), ('new col2', lambda r: r.c2)]. "
+                    f"Element at index {i} (0-indexed) is incompatible"
+                )
+        self.__new_column_expressions = col_expressions
+
+    def to_sql(self, config: FrameToSqlConfig) -> QuerySpecification:
+        base_query = self.__base_frame.to_sql_query_object(config)
+        db_extension = config.sql_to_string_generator().get_db_extension()
+        new_query = create_sub_query(base_query, config, "root")
+        new_select_items: PyLegendList[SelectItem] = []
+        for c in self.__new_column_expressions:
+            if isinstance(c[1], (bool, int, float, str, date, datetime)):
+                col_sql_expr = convert_literal_to_literal_expression(c[1]).to_sql_expression(
+                    {"r": new_query},
+                    config
+                )
+            else:
+                col_sql_expr = c[1].to_sql_expression({"r": new_query}, config)
+            new_select_items.append(
+                SingleColumn(alias=db_extension.quote_identifier(c[0]), expression=col_sql_expr)
+            )
+        new_query.select.selectItems = new_select_items
+        return new_query
+
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        def render_single_column_expression(
+                c: PyLegendUnion[
+                    PyLegendTuple[str, PyLegendPrimitiveOrPythonPrimitive],
+                    PyLegendTuple[str, PyLegendPrimitiveOrPythonPrimitive, PyLegendPrimitive]
+                ]
+        ) -> str:
+            escaped_col_name = escape_column_name(c[0])
+            expr_str = (c[1].to_pure_expression(config) if isinstance(c[1], PyLegendPrimitive) else
+                        convert_literal_to_literal_expression(c[1]).to_pure_expression(config))
+            return f"{escaped_col_name}:{generate_pure_lambda('r', expr_str)}"
+
+        project_str = (f"->project(~[{config.separator(2)}" +
+                       ("," + config.separator(2, True)).join(
+                          [render_single_column_expression(x) for x in self.__new_column_expressions]
+                       ) +
+                       f"{config.separator(1)}])")
+        return f"{self.__base_frame.to_pure(config)}{config.separator(1)}" + project_str
+
+    def base_frame(self) -> LegendQLApiBaseTdsFrame:
+        return self.__base_frame
+
+    def tds_frame_parameters(self) -> PyLegendList["LegendQLApiBaseTdsFrame"]:
+        return []
+
+    def calculate_columns(self) -> PyLegendSequence["TdsColumn"]:
+        new_columns = []
+        for c in self.__new_column_expressions:
+            new_columns.append(tds_column_for_primitive(c[0], c[1] if len(c) == 2 else c[2]))
+        return new_columns
+
+    def validate(self) -> bool:
+        col_names = [x[0] for x in self.__new_column_expressions]
+        if len(col_names) != len(set(col_names)):
+            raise ValueError(f"Project column names list has duplicates: {col_names}")
+        return True

pylegend/core/tds/legendql_api/frames/functions/legendql_api_rename_function.py

@@ -0,0 +1,189 @@
+# 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 pylegend._typing import (
+    PyLegendList,
+    PyLegendSequence,
+    PyLegendCallable,
+    PyLegendUnion,
+    PyLegendTuple,
+)
+from pylegend.core.language import PyLegendColumnExpression
+from pylegend.core.language.legendql_api.legendql_api_custom_expressions import LegendQLApiPrimitive
+from pylegend.core.language.legendql_api.legendql_api_tds_row import LegendQLApiTdsRow
+from pylegend.core.tds.legendql_api.frames.legendql_api_applied_function_tds_frame import LegendQLApiAppliedFunction
+from pylegend.core.tds.sql_query_helpers import copy_query
+from pylegend.core.sql.metamodel import (
+    QuerySpecification,
+    SingleColumn,
+    SelectItem,
+)
+from pylegend.core.tds.tds_column import TdsColumn
+from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.core.tds.tds_frame import FrameToPureConfig
+from pylegend.core.tds.legendql_api.frames.legendql_api_base_tds_frame import LegendQLApiBaseTdsFrame
+from pylegend.core.language.shared.helpers import escape_column_name
+
+
+__all__: PyLegendSequence[str] = [
+    "LegendQLApiRenameFunction"
+]
+
+
+class LegendQLApiRenameFunction(LegendQLApiAppliedFunction):
+    __base_frame: LegendQLApiBaseTdsFrame
+    __column_names: PyLegendList[str]
+    __renamed_column_names: PyLegendList[str]
+
+    @classmethod
+    def name(cls) -> str:
+        return "renameColumns"
+
+    def __init__(
+            self,
+            base_frame: LegendQLApiBaseTdsFrame,
+            column_renames: PyLegendUnion[
+                PyLegendTuple[str, str],
+                PyLegendList[PyLegendTuple[str, str]],
+                PyLegendCallable[
+                    [LegendQLApiTdsRow],
+                    PyLegendUnion[
+                        PyLegendTuple[LegendQLApiPrimitive, str],
+                        PyLegendList[PyLegendTuple[LegendQLApiPrimitive, str]]
+                    ]
+                ]
+            ]
+    ) -> None:
+        self.__base_frame = base_frame
+
+        col_names: PyLegendList[str] = []
+        renamed_col_names: PyLegendList[str] = []
+
+        def rename_tuple_check(t):  # type: ignore
+            return isinstance(t, tuple) and (len(t) == 2) and isinstance(t[0], str) and isinstance(t[1], str)
+
+        if rename_tuple_check(column_renames):  # type: ignore
+            col_names.append(column_renames[0])  # type: ignore
+            renamed_col_names.append(column_renames[1])  # type: ignore
+
+        elif isinstance(column_renames, list) and all([rename_tuple_check(r) for r in column_renames]):  # type: ignore
+            for t in column_renames:
+                col_names.append(t[0])
+                renamed_col_names.append(t[1])
+
+        elif isinstance(column_renames, type(lambda x: 0)) and (column_renames.__code__.co_argcount == 1):
+            tds_row = LegendQLApiTdsRow.from_tds_frame("frame", self.__base_frame)
+            try:
+                result = column_renames(tds_row)
+            except Exception as e:
+                raise RuntimeError(
+                    "rename' function column_renames argument lambda incompatible. "
+                    "Error occurred while evaluating. Message: " + str(e)
+                ) from e
+
+            list_result = result if isinstance(result, list) else [result]
+            for (i, r) in enumerate(list_result):
+                if (isinstance(r, tuple) and (len(r) == 2) and
+                        isinstance(r[0], LegendQLApiPrimitive) and isinstance(r[0].value(), PyLegendColumnExpression)
+                        and isinstance(r[1], str)):
+                    col_expr: PyLegendColumnExpression = r[0].value()
+                    col_names.append(col_expr.get_column())
+                    renamed_col_names.append(r[1])
+                else:
+                    raise TypeError(
+                        "'rename' function column_renames argument lambda incompatible. Each element in rename list "
+                        "should be a tuple with first element being a simple column expression and "
+                        "second element being a string (renamed column name) "
+                        f"(E.g - lambda r: [(r.c1, 'c2')]). Element at index {i} (0-indexed) is incompatible"
+                    )
+
+        else:
+            raise TypeError("'rename' function column_renames argument can either be a list of renaming tuples or "
+                            "a lambda function which takes one argument (LegendQLApiTdsRow)")
+
+        self.__column_names = col_names
+        self.__renamed_column_names = renamed_col_names
+
+    def to_sql(self, config: FrameToSqlConfig) -> QuerySpecification:
+        base_query = self.__base_frame.to_sql_query_object(config)
+
+        db_extension = config.sql_to_string_generator().get_db_extension()
+        quoted_column_names_to_change = [db_extension.quote_identifier(s) for s in self.__column_names]
+        quoted_renamed_column_names = [db_extension.quote_identifier(s) for s in self.__renamed_column_names]
+
+        new_select_items: PyLegendList[SelectItem] = []
+        for col in base_query.select.selectItems:
+            if not isinstance(col, SingleColumn):
+                raise ValueError("Rename columns operation not supported for queries "
+                                 "with columns other than SingleColumn")  # pragma: no cover
+            if col.alias is None:
+                raise ValueError("Rename columns operation not supported for queries "
+                                 "with SingleColumns with missing alias")  # pragma: no cover
+            if col.alias in quoted_column_names_to_change:
+                new_alias = quoted_renamed_column_names[quoted_column_names_to_change.index(col.alias)]
+                new_select_items.append(SingleColumn(alias=new_alias, expression=col.expression))
+            else:
+                new_select_items.append(col)
+
+        new_query = copy_query(base_query)
+        new_query.select.selectItems = new_select_items
+        return new_query
+
+    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) -> LegendQLApiBaseTdsFrame:
+        return self.__base_frame
+
+    def tds_frame_parameters(self) -> PyLegendList["LegendQLApiBaseTdsFrame"]:
+        return []
+
+    def calculate_columns(self) -> PyLegendSequence["TdsColumn"]:
+        new_columns = []
+        for base_col in self.__base_frame.columns():
+            if base_col.get_name() in self.__column_names:
+                renamed_column_name = self.__renamed_column_names[self.__column_names.index(base_col.get_name())]
+                new_columns.append(base_col.copy_with_changed_name(renamed_column_name))
+            else:
+                new_columns.append(base_col.copy())
+        return new_columns
+
+    def validate(self) -> bool:
+        if len(self.__column_names) != len(self.__renamed_column_names):
+            raise ValueError(
+                "column_names list and renamed_column_names list should have same size when renaming columns.\n"
+                f"column_names list - (Count: {len(self.__column_names)}) - {self.__column_names}\n"
+                f"renamed_column_names_list - (Count: {len(self.__renamed_column_names)}) - {self.__renamed_column_names}\n"
+            )
+
+        if len(self.__column_names) != len(set(self.__column_names)):
+            raise ValueError(
+                "column_names list shouldn't have duplicates when renaming columns.\n"
+                f"column_names list - (Count: {len(self.__column_names)}) - {self.__column_names}\n"
+            )
+
+        if len(self.__renamed_column_names) != len(set(self.__renamed_column_names)):
+            raise ValueError(
+                "renamed_column_names_list list shouldn't have duplicates when renaming columns.\n"
+                f"renamed_column_names_list - (Count: {len(self.__renamed_column_names)}) - {self.__renamed_column_names}\n"
+            )
+
+        return True

pylegend/core/tds/legendql_api/frames/functions/legendql_api_select_function.py

@@ -0,0 +1,131 @@
+# 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 pylegend._typing import (
+    PyLegendList,
+    PyLegendSequence,
+    PyLegendTuple,
+    PyLegendCallable,
+    PyLegendUnion,
+)
+from pylegend.core.language.legendql_api.legendql_api_custom_expressions import LegendQLApiPrimitive
+from pylegend.core.language.legendql_api.legendql_api_tds_row import LegendQLApiTdsRow
+from pylegend.core.tds.legendql_api.frames.functions.legendql_api_function_helpers import infer_columns_from_frame
+from pylegend.core.tds.legendql_api.frames.legendql_api_applied_function_tds_frame import LegendQLApiAppliedFunction
+from pylegend.core.tds.sql_query_helpers import copy_query, create_sub_query
+from pylegend.core.sql.metamodel import (
+    QuerySpecification,
+    SingleColumn,
+    SelectItem
+)
+from pylegend.core.tds.tds_column import TdsColumn
+from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.core.tds.tds_frame import FrameToPureConfig
+from pylegend.core.tds.legendql_api.frames.legendql_api_base_tds_frame import LegendQLApiBaseTdsFrame
+from pylegend.core.language.shared.helpers import escape_column_name
+
+
+__all__: PyLegendSequence[str] = [
+    "LegendQLApiSelectFunction"
+]
+
+
+class LegendQLApiSelectFunction(LegendQLApiAppliedFunction):
+    __base_frame: LegendQLApiBaseTdsFrame
+    __column_name_list: PyLegendList[str]
+
+    @classmethod
+    def name(cls) -> str:
+        return "select"
+
+    def __init__(
+            self,
+            base_frame: LegendQLApiBaseTdsFrame,
+            columns: PyLegendUnion[
+                str,
+                PyLegendList[str],
+                PyLegendCallable[
+                    [LegendQLApiTdsRow],
+                    PyLegendUnion[LegendQLApiPrimitive, PyLegendList[LegendQLApiPrimitive]]
+                ]
+            ]
+    ) -> None:
+        self.__base_frame = base_frame
+        self.__column_name_list = infer_columns_from_frame(base_frame, columns, "'select' function 'columns'")
+
+    def to_sql(self, config: FrameToSqlConfig) -> QuerySpecification:
+        base_query = self.__base_frame.to_sql_query_object(config)
+        db_extension = config.sql_to_string_generator().get_db_extension()
+        columns_to_retain = [db_extension.quote_identifier(x) for x in self.__column_name_list]
+
+        sub_query_required = (len(base_query.groupBy) > 0) or (len(base_query.orderBy) > 0) or \
+                             (base_query.having is not None) or base_query.select.distinct
+
+        if sub_query_required:
+            new_query = create_sub_query(base_query, config, "root", columns_to_retain=columns_to_retain)
+            return new_query
+        else:
+            new_cols_with_index: PyLegendList[PyLegendTuple[int, 'SelectItem']] = []
+            for col in base_query.select.selectItems:
+                if not isinstance(col, SingleColumn):
+                    raise ValueError("Select operation not supported for queries "
+                                     "with columns other than SingleColumn")  # pragma: no cover
+                if col.alias is None:
+                    raise ValueError("Select operation not supported for queries "
+                                     "with SingleColumns with missing alias")  # pragma: no cover
+                if col.alias in columns_to_retain:
+                    new_cols_with_index.append((columns_to_retain.index(col.alias), col))
+
+            new_select_items = [y[1] for y in sorted(new_cols_with_index, key=lambda x: x[0])]
+            new_query = copy_query(base_query)
+            new_query.select.selectItems = new_select_items
+            return new_query
+
+    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) -> LegendQLApiBaseTdsFrame:
+        return self.__base_frame
+
+    def tds_frame_parameters(self) -> PyLegendList["LegendQLApiBaseTdsFrame"]:
+        return []
+
+    def calculate_columns(self) -> PyLegendSequence["TdsColumn"]:
+        base_columns = self.__base_frame.columns()
+        new_columns = []
+        for c in self.__column_name_list:
+            for base_col in base_columns:
+                if base_col.get_name() == c:
+                    new_columns.append(base_col.copy())
+                    break
+        return new_columns
+
+    def validate(self) -> bool:
+        base_columns = self.__base_frame.columns()
+        for c in self.__column_name_list:
+            found_col = False
+            for base_col in base_columns:
+                if base_col.get_name() == c:
+                    found_col = True
+                    break
+            if not found_col:
+                raise ValueError(
+                    f"Column - '{c}' in select columns list doesn't exist in the current frame. "
+                    f"Current frame columns: {[x.get_name() for x in base_columns]}"
+                )
+        return True

pylegend/core/tds/legendql_api/frames/functions/legendql_api_slice_function.py

@@ -0,0 +1,82 @@
+# 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 pylegend._typing import (
+    PyLegendList,
+    PyLegendSequence
+)
+from pylegend.core.tds.legendql_api.frames.legendql_api_applied_function_tds_frame import LegendQLApiAppliedFunction
+from pylegend.core.tds.sql_query_helpers import copy_query, create_sub_query
+from pylegend.core.sql.metamodel import (
+    QuerySpecification,
+    LongLiteral,
+)
+from pylegend.core.tds.tds_column import TdsColumn
+from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.core.tds.tds_frame import FrameToPureConfig
+from pylegend.core.tds.legendql_api.frames.legendql_api_base_tds_frame import LegendQLApiBaseTdsFrame
+
+
+__all__: PyLegendSequence[str] = [
+    "LegendQLApiSliceFunction"
+]
+
+
+class LegendQLApiSliceFunction(LegendQLApiAppliedFunction):
+    __base_frame: LegendQLApiBaseTdsFrame
+    __start_row: int
+    __end_row: int
+
+    @classmethod
+    def name(cls) -> str:
+        return "slice"
+
+    def __init__(self, base_frame: LegendQLApiBaseTdsFrame, start_row: int, end_row: int) -> None:
+        self.__base_frame = base_frame
+        self.__start_row = start_row
+        self.__end_row = end_row
+
+    def to_sql(self, config: FrameToSqlConfig) -> QuerySpecification:
+        base_query = self.__base_frame.to_sql_query_object(config)
+        should_create_sub_query = (base_query.offset is not None) or (base_query.limit is not None)
+        new_query = (
+            create_sub_query(base_query, config, "root") if should_create_sub_query else
+            copy_query(base_query)
+        )
+        new_query.offset = LongLiteral(self.__start_row)
+        new_query.limit = LongLiteral(self.__end_row - self.__start_row)
+        return new_query
+
+    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) -> LegendQLApiBaseTdsFrame:
+        return self.__base_frame
+
+    def tds_frame_parameters(self) -> PyLegendList["LegendQLApiBaseTdsFrame"]:
+        return []
+
+    def calculate_columns(self) -> PyLegendSequence["TdsColumn"]:
+        return [c.copy() for c in self.__base_frame.columns()]
+
+    def validate(self) -> bool:
+        if self.__start_row < 0:
+            raise ValueError(
+                "Start row argument of slice function cannot be negative. Start row: " + str(self.__start_row)
+            )
+        if self.__end_row <= self.__start_row:
+            raise ValueError("End row argument of slice function cannot be less than or equal to start row argument. "
+                             f"Start row: {self.__start_row}, End row: {self.__end_row}")
+        return True

pylegend/core/tds/legendql_api/frames/functions/legendql_api_sort_function.py

@@ -0,0 +1,93 @@
+# 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 pylegend._typing import (
+    PyLegendList,
+    PyLegendSequence,
+    PyLegendCallable,
+    PyLegendUnion,
+)
+from pylegend.core.language.legendql_api.legendql_api_custom_expressions import (
+    LegendQLApiPrimitive,
+    LegendQLApiSortInfo,
+)
+from pylegend.core.language.legendql_api.legendql_api_tds_row import LegendQLApiTdsRow
+from pylegend.core.sql.metamodel import (
+    QuerySpecification,
+)
+from pylegend.core.tds.legendql_api.frames.functions.legendql_api_function_helpers import infer_sorts_from_frame
+from pylegend.core.tds.legendql_api.frames.legendql_api_applied_function_tds_frame import LegendQLApiAppliedFunction
+from pylegend.core.tds.legendql_api.frames.legendql_api_base_tds_frame import LegendQLApiBaseTdsFrame
+from pylegend.core.tds.sql_query_helpers import copy_query, create_sub_query
+from pylegend.core.tds.tds_column import TdsColumn
+from pylegend.core.tds.tds_frame import FrameToPureConfig
+from pylegend.core.tds.tds_frame import FrameToSqlConfig
+
+__all__: PyLegendSequence[str] = [
+    "LegendQLApiSortFunction"
+]
+
+
+class LegendQLApiSortFunction(LegendQLApiAppliedFunction):
+    __base_frame: LegendQLApiBaseTdsFrame
+    __sort_infos: PyLegendList[LegendQLApiSortInfo]
+
+    @classmethod
+    def name(cls) -> str:
+        return "sort"
+
+    def __init__(
+            self,
+            base_frame: LegendQLApiBaseTdsFrame,
+            sort_infos: PyLegendUnion[
+                str,
+                PyLegendList[str],
+                PyLegendCallable[
+                    [LegendQLApiTdsRow],
+                    PyLegendUnion[
+                        LegendQLApiPrimitive,
+                        LegendQLApiSortInfo,
+                        PyLegendList[PyLegendUnion[LegendQLApiPrimitive, LegendQLApiSortInfo]],
+                    ]
+                ]
+            ]
+    ) -> None:
+        self.__base_frame = base_frame
+        self.__sort_infos = infer_sorts_from_frame(base_frame, sort_infos, "'sort' function sort_infos")
+
+    def to_sql(self, config: FrameToSqlConfig) -> QuerySpecification:
+        base_query = self.__base_frame.to_sql_query_object(config)
+        should_create_sub_query = (base_query.offset is not None) or (base_query.limit is not None)
+        new_query = (
+            create_sub_query(base_query, config, "root") if should_create_sub_query else
+            copy_query(base_query)
+        )
+        new_query.orderBy = [i.to_sql_node(query=new_query, config=config) for i in self.__sort_infos]
+        return new_query
+
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        return (f"{self.__base_frame.to_pure(config)}{config.separator(1)}" +
+                f"->sort([{', '.join([i.to_pure_expression(config) for i in self.__sort_infos])}])")
+
+    def base_frame(self) -> LegendQLApiBaseTdsFrame:
+        return self.__base_frame
+
+    def tds_frame_parameters(self) -> PyLegendList["LegendQLApiBaseTdsFrame"]:
+        return []
+
+    def calculate_columns(self) -> PyLegendSequence["TdsColumn"]:
+        return [c.copy() for c in self.__base_frame.columns()]
+
+    def validate(self) -> bool:
+        return True