pylegend 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

pylegend/core/tds/pandas_api/frames/functions/drop.py

@@ -0,0 +1,171 @@
+# 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,
+    PyLegendSet,
+    PyLegendSequence,
+    PyLegendUnion,
+    PyLegendOptional
+)
+from pylegend.core.language.shared.primitives.boolean import PyLegendBoolean
+from pylegend.core.language.shared.primitives.integer import PyLegendInteger
+from pylegend.core.sql.metamodel import (
+    QuerySpecification
+)
+from pylegend.core.tds.pandas_api.frames.functions.filter import PandasApiFilterFunction
+from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import PandasApiAppliedFunction
+from pylegend.core.tds.pandas_api.frames.pandas_api_base_tds_frame import PandasApiBaseTdsFrame
+from pylegend.core.tds.tds_column import TdsColumn
+from pylegend.core.tds.tds_frame import FrameToPureConfig, FrameToSqlConfig
+
+__all__: PyLegendSequence[str] = [
+    "PandasApiDropFunction"
+]
+
+
+class PandasApiDropFunction(PandasApiAppliedFunction):
+    __base_frame: PandasApiBaseTdsFrame
+    __labels: PyLegendOptional[PyLegendUnion[str, PyLegendSequence[str], PyLegendSet[str]]]
+    __axis: PyLegendUnion[str, int, PyLegendInteger]
+    __index: PyLegendOptional[PyLegendUnion[str, PyLegendSequence[str], PyLegendSet[str]]]
+    __columns: PyLegendOptional[PyLegendUnion[str, PyLegendSequence[str], PyLegendSet[str]]]
+    __level: PyLegendOptional[PyLegendUnion[int, PyLegendInteger, str]]
+    __inplace: PyLegendUnion[bool, PyLegendBoolean]
+    __errors: str
+
+    @classmethod
+    def name(cls) -> str:
+        return "drop"  # pragma: no cover
+
+    def __init__(
+            self,
+            base_frame: PandasApiBaseTdsFrame,
+            labels: PyLegendOptional[PyLegendUnion[str, PyLegendSequence[str], PyLegendSet[str]]],
+            axis: PyLegendUnion[str, int, PyLegendInteger],
+            index: PyLegendOptional[PyLegendUnion[str, PyLegendSequence[str], PyLegendSet[str]]],
+            columns: PyLegendOptional[PyLegendUnion[str, PyLegendSequence[str], PyLegendSet[str]]],
+            level: PyLegendOptional[PyLegendUnion[int, PyLegendInteger, str]],
+            inplace: PyLegendUnion[bool, PyLegendBoolean],
+            errors: str
+    ) -> None:
+        self.__base_frame = base_frame
+        self.__labels = labels
+        self.__axis = axis
+        self.__index = index
+        self.__columns = columns
+        self.__level = level
+        self.__inplace = inplace
+        self.__errors = errors
+
+    def to_sql(self, config: FrameToSqlConfig) -> QuerySpecification:
+        base_cols = [c.get_name() for c in self.__base_frame.columns()]
+
+        if self.__errors == "raise":
+            not_found = [col for col in self.__columns if col not in base_cols]  # type: ignore
+            if not_found:
+                raise KeyError(f"{not_found} not found in axis")
+
+        columns_to_retain = [col for col in base_cols if col not in self.__columns]  # type: ignore
+        filter_func = PandasApiFilterFunction(
+            base_frame=self.__base_frame,
+            items=columns_to_retain,
+            like=None,
+            regex=None,
+            axis=1
+        )
+        return filter_func.to_sql(config)
+
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        base_cols = [c.get_name() for c in self.__base_frame.columns()]
+        if self.__errors == "raise":
+            not_found = [col for col in self.__columns if col not in base_cols]  # type: ignore
+            if not_found:
+                raise KeyError(f"{not_found} not found in axis")
+
+        columns_to_retain = [col for col in base_cols if col not in self.__columns]  # type: ignore
+        filter_func = PandasApiFilterFunction(
+            base_frame=self.__base_frame,
+            items=columns_to_retain,
+            like=None,
+            regex=None,
+            axis=1
+        )
+        return filter_func.to_pure(config)
+
+    def base_frame(self) -> PandasApiBaseTdsFrame:
+        return self.__base_frame
+
+    def tds_frame_parameters(self) -> PyLegendList["PandasApiBaseTdsFrame"]:
+        return []
+
+    def calculate_columns(self) -> PyLegendSequence["TdsColumn"]:
+        base_cols = [c.copy() for c in self.__base_frame.columns()]
+        if self.__columns is not None:
+            new_cols = []
+            for col in base_cols:
+                if col.get_name() not in self.__columns:
+                    new_cols.append(col.copy())
+            return new_cols
+        return base_cols  # pragma: no cover
+
+    def validate(self) -> bool:
+        valid_paramters: int = 0
+        if self.__axis is not None:
+            if isinstance(self.__axis, (str, int, PyLegendInteger)):
+                if self.__axis != 1 and self.__axis != "columns":
+                    if self.__axis == 0 or self.__axis == "index":
+                        raise NotImplementedError(
+                            f"Axis {self.__axis} is not supported for 'drop' function in PandasApi")
+                    else:
+                        raise ValueError(f"No axis named {self.__axis} for object type Tds DataFrame")
+            else:
+                raise TypeError(f"No axis named {self.__axis} for object type Tds DataFrame")  # pragma: no cover
+        if self.__level is not None:
+            raise NotImplementedError("'level' parameter is not supported for 'drop' function in PandasApi")
+
+        if self.__index is not None:
+            raise NotImplementedError("'index' parameter is not supported for 'drop' function in PandasApi")
+
+        if self.__labels is not None:
+            valid_paramters += 1
+
+            if self.__columns is None:
+                self.__columns = self.__labels
+            else:
+                raise ValueError("Cannot specify both 'labels' and 'columns'")
+
+        if self.__columns is not None:
+            def _normalize_columns(columns):  # type: ignore
+                if columns is None:
+                    return []  # pragma: no cover
+                if isinstance(columns, str):
+                    return [columns]
+                if isinstance(columns, (PyLegendSequence, PyLegendSet)):
+                    return list(columns)
+                raise TypeError(f"Unsupported type for columns: {type(columns)}")
+
+            valid_paramters += 1
+            self.__columns = _normalize_columns(self.__columns)  # type: ignore
+
+        if isinstance(self.__inplace, (bool, PyLegendBoolean)):
+            if self.__inplace is False:
+                raise NotImplementedError(f"Only inplace=True is supported. Got inplace={self.__inplace!r}")
+        else:
+            raise TypeError(f"Inplace must be True. Got inplace={self.__inplace!r}")  # pragma: no cover
+
+        if valid_paramters == 0:
+            raise ValueError("Need to specify at least one of 'labels' or 'columns'")
+
+        return True

pylegend/core/tds/pandas_api/frames/functions/filter.py

@@ -0,0 +1,193 @@
+# 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.
+
+import re
+
+from pylegend._typing import (
+    PyLegendUnion,
+    PyLegendOptional,
+    PyLegendSequence,
+    PyLegendList,
+    PyLegendTuple
+)
+from pylegend.core.language import (
+    PyLegendInteger,
+)
+from pylegend.core.language.shared.helpers import escape_column_name
+from pylegend.core.sql.metamodel import (
+    QuerySpecification,
+    SingleColumn,
+    SelectItem
+)
+from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import (
+    PandasApiAppliedFunction,
+)
+from pylegend.core.tds.pandas_api.frames.pandas_api_base_tds_frame import (
+    PandasApiBaseTdsFrame,
+)
+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 FrameToSqlConfig, FrameToPureConfig
+
+__all__: PyLegendSequence[str] = ["PandasApiFilterFunction"]
+
+
+class PandasApiFilterFunction(PandasApiAppliedFunction):
+    __base_frame: PandasApiBaseTdsFrame
+    __items: PyLegendOptional[PyLegendList[str]]
+    __like: PyLegendOptional[str]
+    __regex: PyLegendOptional[str]
+    __axis: PyLegendOptional[PyLegendUnion[str, int, PyLegendInteger]]
+
+    @classmethod
+    def name(cls) -> str:
+        return "filter"  # pragma: no cover
+
+    def __init__(
+            self,
+            base_frame: PandasApiBaseTdsFrame,
+            items: PyLegendOptional[PyLegendList[str]],
+            like: PyLegendOptional[str],
+            regex: PyLegendOptional[str],
+            axis: PyLegendOptional[PyLegendUnion[str, int, PyLegendInteger]],
+    ) -> None:
+        self.__base_frame = base_frame
+        self.__items = items
+        self.__like = like
+        self.__regex = regex
+        self.__axis = 1 if axis is None else axis
+
+    def __get_desired_columns(
+            self, col_names: PyLegendSequence[str]
+    ) -> PyLegendSequence[str]:
+        if self.__items is not None:
+            return self.__items
+        elif self.__like is not None:
+            return [col for col in col_names if self.__like in col]
+        elif self.__regex is not None:
+            regex_pattern = re.compile(self.__regex)
+            return [col for col in col_names if regex_pattern.search(col)]
+
+        return []  # pragma: no cover
+
+    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.__get_desired_columns([c.get_name() for c in self.__base_frame.columns()])]
+
+        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")
+                if col.alias is None:
+                    raise ValueError("Select operation not supported for queries with SingleColumns with missing alias")
+                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:
+        col_names = [c.get_name() for c in self.__base_frame.columns()]
+        desired_columns = self.__get_desired_columns(col_names)
+        escaped_columns = [escape_column_name(col_name) for col_name in desired_columns]
+        return (
+            f"{self.__base_frame.to_pure(config)}{config.separator(1)}"
+            f"->select(~[{', '.join(escaped_columns)}])"
+        )
+
+    def base_frame(self) -> PandasApiBaseTdsFrame:
+        return self.__base_frame
+
+    def tds_frame_parameters(self) -> PyLegendList["PandasApiBaseTdsFrame"]:
+        return []
+
+    def calculate_columns(self) -> PyLegendSequence["TdsColumn"]:
+        base_cols = [c.copy() for c in self.__base_frame.columns()]
+        desired_col_names = self.__get_desired_columns([c.get_name() for c in base_cols])
+        return [
+            base_col.copy()
+            for base_col in base_cols
+            if base_col.get_name() in desired_col_names
+        ]
+
+    def validate(self) -> bool:
+        mutual_exclusion = sum(
+            [
+                self.__items is not None,
+                self.__like is not None,
+                self.__regex is not None,
+            ]
+        )
+        if mutual_exclusion > 1:
+            raise TypeError(
+                "Keyword arguments `items`, `like`, or `regex` are mutually exclusive"
+            )
+        if mutual_exclusion == 0:
+            raise TypeError("Must pass either `items`, `like`, or `regex`")
+
+        base_cols = [c.get_name() for c in self.__base_frame.columns()]
+        if self.__items is not None:
+            if not isinstance(self.__items, (list, PyLegendList)):
+                raise TypeError(
+                    f"Index(...) must be called with a collection, got '{self.__items}'"
+                )
+            invalid_cols = [item for item in self.__items if item not in base_cols]
+            if invalid_cols:
+                raise ValueError(
+                    f"Columns {invalid_cols} in `filter` items list do not exist. Available: {base_cols}"
+                )
+
+        if self.__like is not None:
+            if not isinstance(self.__like, str):
+                raise TypeError(f"'like' must be a string, got {type(self.__like)}")
+            if not any(self.__like in col for col in base_cols):
+                raise ValueError(
+                    f"No columns match the pattern '{self.__like}'. Available: {base_cols}"
+                )
+
+        if self.__regex is not None:
+            if not isinstance(self.__regex, str):
+                raise TypeError(f"'regex' must be a string, got {type(self.__regex)}")
+            try:
+                regex_pattern = re.compile(self.__regex)
+            except re.error as e:
+                raise ValueError(f"Invalid regex pattern '{self.__regex}': {e}")
+            if not any(regex_pattern.search(col) for col in base_cols):
+                raise ValueError(
+                    f"No columns match the regex '{self.__regex}'. Available: {base_cols}"
+                )
+
+        if not isinstance(
+                self.__axis, (str, int, PyLegendInteger)
+        ) or self.__axis not in [1, "columns"]:
+            raise ValueError(
+                f"Unsupported axis value: {self.__axis}. Expected 1 or 'columns'"
+            )
+
+        return True

pylegend/core/tds/pandas_api/frames/functions/filtering.py

@@ -0,0 +1,85 @@
+# 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 (
+    PyLegendSequence,
+    PyLegendList
+)
+from pylegend.core.language import PyLegendBoolean
+from pylegend.core.sql.metamodel import (
+    QuerySpecification,
+    LogicalBinaryExpression,
+    LogicalBinaryType,
+)
+from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import PandasApiAppliedFunction
+from pylegend.core.tds.pandas_api.frames.pandas_api_base_tds_frame import PandasApiBaseTdsFrame
+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 FrameToSqlConfig, FrameToPureConfig
+
+__all__: PyLegendSequence[str] = ["PandasApiFilteringFunction"]
+
+
+class PandasApiFilteringFunction(PandasApiAppliedFunction):
+    __base_frame: PandasApiBaseTdsFrame
+    __filter_expr: PyLegendBoolean
+
+    @classmethod
+    def name(cls) -> str:
+        return "boolean_filter"  # pragma: no cover
+
+    def __init__(
+            self,
+            base_frame: PandasApiBaseTdsFrame,
+            filter_expr: PyLegendBoolean
+    ) -> None:
+        self.__base_frame = base_frame
+        self.__filter_expr = filter_expr
+
+    def to_sql(self, config: FrameToSqlConfig) -> QuerySpecification:
+        base_query = self.__base_frame.to_sql_query_object(config)
+        should_create_sub_query = (len(base_query.groupBy) > 0) or \
+                                  (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)
+        )
+
+        sql_expr = self.__filter_expr.to_sql_expression({"c": new_query}, config)
+
+        if new_query.where is None:
+            new_query.where = sql_expr
+        else:
+            new_query.where = LogicalBinaryExpression(
+                type_=LogicalBinaryType.AND,
+                left=new_query.where,
+                right=sql_expr
+            )
+        return new_query
+
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        pure_expr = self.__filter_expr.to_pure_expression(config)
+        return f"{self.__base_frame.to_pure(config)}{config.separator(1)}->filter(c|{pure_expr})"
+
+    def base_frame(self) -> PandasApiBaseTdsFrame:
+        return self.__base_frame
+
+    def tds_frame_parameters(self) -> PyLegendList["PandasApiBaseTdsFrame"]:
+        return []
+
+    def calculate_columns(self) -> PyLegendSequence["TdsColumn"]:
+        return [c.copy() for c in self.__base_frame.columns()]
+
+    def validate(self) -> bool:
+        return True

pylegend/core/tds/pandas_api/frames/functions/sort_values_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 (
+    PyLegendUnion,
+    PyLegendOptional,
+    PyLegendCallable,
+    PyLegendList,
+    PyLegendSequence,
+)
+from pylegend.core.language.shared.tds_row import AbstractTdsRow
+from pylegend.core.sql.metamodel import (
+    QuerySpecification,
+    SortItemOrdering,
+    SortItem,
+    SortItemNullOrdering, SingleColumn, Expression,
+)
+from pylegend.core.tds.pandas_api.frames.pandas_api_applied_function_tds_frame import (
+    PandasApiAppliedFunction,
+)
+from pylegend.core.tds.pandas_api.frames.pandas_api_base_tds_frame import (
+    PandasApiBaseTdsFrame,
+)
+from pylegend.core.tds.sql_query_helpers import create_sub_query, copy_query
+from pylegend.core.tds.tds_frame import FrameToSqlConfig, FrameToPureConfig
+from pylegend.core.tds.tds_column import TdsColumn
+from pylegend.core.language.shared.helpers import escape_column_name
+
+
+class SortValuesFunction(PandasApiAppliedFunction):
+    __base_frame: PandasApiBaseTdsFrame
+    __by: PyLegendList[str]
+    __axis: PyLegendUnion[str, int]
+    __ascending: PyLegendList[bool]
+    __inplace: bool
+    __kind: PyLegendOptional[str]
+    __na_position: str
+    __ignore_index: bool
+    key: PyLegendOptional[PyLegendCallable[[AbstractTdsRow], AbstractTdsRow]] = None
+
+    @classmethod
+    def name(cls) -> str:
+        return "sort_values"  # pragma: no cover
+
+    def __init__(
+            self,
+            base_frame: PandasApiBaseTdsFrame,
+            by: PyLegendUnion[str, PyLegendList[str]],
+            axis: PyLegendUnion[str, int],
+            ascending: PyLegendUnion[bool, PyLegendList[bool]],
+            inplace: bool,
+            kind: PyLegendOptional[str],
+            na_position: str,
+            ignore_index: bool,
+            key: PyLegendOptional[PyLegendCallable[[AbstractTdsRow], AbstractTdsRow]] = None
+    ) -> None:
+        self.__base_frame = base_frame
+        self.__by_input = by
+        self.__axis = axis
+        self.__ascending_input = ascending
+        self.__inplace = inplace
+        self.__kind = kind
+        self.__na_position = na_position
+        self.__ignore_index = ignore_index
+        self.__key = key
+
+    def to_sql(self, config: FrameToSqlConfig) -> QuerySpecification:
+        base_query: QuerySpecification = 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 = [
+            SortItem(
+                sortKey=self.get_expression_from_column_name(new_query, column_name, config),
+                ordering=(
+                    SortItemOrdering.ASCENDING if ascending
+                    else SortItemOrdering.DESCENDING
+                ),
+                nullOrdering=SortItemNullOrdering.UNDEFINED,
+            )
+            for column_name, ascending in zip(self.__by, self.__ascending)
+        ]
+        return new_query
+
+    def get_expression_from_column_name(self, query: QuerySpecification, column_name: str,
+                                        config: FrameToSqlConfig) -> Expression:
+        db_extension = config.sql_to_string_generator().get_db_extension()
+        filtered = [
+            s for s in query.select.selectItems
+            if (isinstance(s, SingleColumn) and
+                s.alias == db_extension.quote_identifier(column_name))
+        ]
+        if len(filtered) == 0:
+            raise RuntimeError("Cannot find column: " + column_name)  # pragma: no cover
+        return filtered[0].expression
+
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        escaped_columns = []
+        for col_name in self.__by:
+            escaped_columns.append(escape_column_name(col_name))
+        sort_items = [
+            f"~{column_name}->ascending()" if ascending else f"~{column_name}->descending()"
+            for column_name, ascending in zip(escaped_columns, self.__ascending)
+        ]
+        return (
+                f"{self.__base_frame.to_pure(config)}{config.separator(1)}"
+                + f"->sort([{', '.join(sort_items)}])"
+        )
+
+    def base_frame(self) -> PandasApiBaseTdsFrame:
+        return self.__base_frame
+
+    def tds_frame_parameters(self) -> PyLegendList["PandasApiBaseTdsFrame"]:
+        return []
+
+    def calculate_columns(self) -> PyLegendSequence["TdsColumn"]:
+        return [c.copy() for c in self.__base_frame.columns()]
+
+    def validate(self) -> bool:
+        if self.__axis not in [0, "index"]:
+            raise ValueError(
+                "Axis parameter of sort_values function must be 0 or 'index'"
+            )
+
+        if self.__inplace is not False:
+            raise ValueError("Inplace parameter of sort_values function must be False")
+
+        if self.__kind is not None:
+            raise NotImplementedError(
+                "Kind parameter of sort_values function is not supported"
+            )
+
+        if self.__ignore_index is not True:
+            raise ValueError(
+                "Ignore_index parameter of sort_values function must be True"
+            )
+
+        if self.__key is not None:
+            raise NotImplementedError(
+                "Key parameter of sort_values function is not supported"
+            )
+
+        base_frame_columns = [
+            column.get_name() for column in self.__base_frame.columns()
+        ]
+
+        self.__by = self._build_by_list()
+        self.__ascending = self._build_ascending_list()
+
+        if len(self.__by) != len(self.__ascending):
+            raise ValueError(
+                "The number of columns in 'by' must equal the number of values in 'ascending' for sort_values function."
+            )
+
+        for column in self.__by:
+            if column not in base_frame_columns:
+                raise ValueError(
+                    f"Column - '{column}' in sort_values columns list doesn't exist in the current frame. "
+                    f"Current frame columns: {base_frame_columns}"
+                )
+
+        return True
+
+    def _build_by_list(self) -> PyLegendList[str]:
+        if isinstance(self.__by_input, str):
+            return [self.__by_input]
+        else:
+            return self.__by_input
+
+    def _build_ascending_list(self) -> PyLegendList[bool]:
+        if self.__ascending_input is True:
+            return [True for _ in self.__by]
+        elif self.__ascending_input is False:
+            return [False for _ in self.__by]
+        else:
+            return self.__ascending_input