pylegend 0.11.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

pylegend/core/database/sql_to_string/db_extension.py

@@ -72,6 +72,10 @@ from pylegend.core.sql.metamodel import (
     Window,
     TableFunction,
     Union,
+    WindowFrame,
+    WindowFrameMode,
+    FrameBound,
+    FrameBoundType
 )
 from pylegend.core.sql.metamodel_extension import (
     StringLengthExpression,
@@ -864,14 +868,27 @@ def window_processor(
     if window.windowRef:
         return window.windowRef
 
-    partitions = "PARTITION BY " + (", ".join([extension.process_expression(e, config) for e in window.partitions])) \
-        if window.partitions else ""
+    clauses: list[str] = []
 
-    order_by = "ORDER BY " + (", ".join([extension.process_sort_item(o, config) for o in window.orderBy])) \
-        if window.orderBy else ""
+    if window.partitions:
+        partition_clause = ", ".join(
+            extension.process_expression(expr, config)
+            for expr in window.partitions
+        )
+        clauses.append(f"PARTITION BY {partition_clause}")
+
+    if window.orderBy:
+        order_clause = ", ".join(
+            extension.process_sort_item(item, config)
+            for item in window.orderBy
+        )
+        clauses.append(f"ORDER BY {order_clause}")
 
-    # TODO: Handle window frame
-    return f"OVER ({partitions}{' ' if (partitions != '') and (order_by != '') else ''}{order_by}){''}"
+    if window.windowFrame:
+        frame_clause = extension.process_window_frame(window.windowFrame, config)
+        clauses.append(frame_clause)
+
+    return f"OVER ({' '.join(clauses)})"
 
 
 def table_function_processor(
@@ -901,6 +918,45 @@ def union_processor(
     return f"{left}{sep0}{union_str}{sep0}{right}"
 
 
+def frame_bound_processor(
+        frame_bound: FrameBound,
+        extension: "SqlToStringDbExtension",
+        config: SqlToStringConfig,
+) -> str:
+    bound_sql = {
+        FrameBoundType.UNBOUNDED_PRECEDING: "UNBOUNDED PRECEDING",
+        FrameBoundType.PRECEDING: "PRECEDING",
+        FrameBoundType.FOLLOWING: "FOLLOWING",
+        FrameBoundType.CURRENT_ROW: "CURRENT ROW",
+        FrameBoundType.UNBOUNDED_FOLLOWING: "UNBOUNDED FOLLOWING",
+    }[frame_bound.type_]
+
+    if frame_bound.value is None:
+        return bound_sql
+
+    offset_expr = extension.process_expression(frame_bound.value, config)
+
+    offset_sql = (
+        f"INTERVAL '{offset_expr} {frame_bound.duration_unit.value}'"
+        if frame_bound.duration_unit
+        else offset_expr
+    )
+
+    return f"{offset_sql} {bound_sql}"
+
+
+def window_frame_processor(
+        frame: WindowFrame,
+        extension: "SqlToStringDbExtension",
+        config: SqlToStringConfig,
+) -> str:
+    mode = "ROWS" if frame.mode == WindowFrameMode.ROWS else "RANGE"
+    start = extension.process_frame_bound(frame.start, config)
+    end = extension.process_frame_bound(frame.end, config) if frame.end else "UNBOUNDED FOLLOWING"
+
+    return f"{mode} BETWEEN {start} AND {end}"
+
+
 class SqlToStringDbExtension:
     @classmethod
     def reserved_keywords(cls) -> PyLegendList[str]:
@@ -1260,3 +1316,9 @@ class SqlToStringDbExtension:
 
     def process_union(self, union: Union, config: SqlToStringConfig, nested_subquery: bool = False) -> str:
         return union_processor(union, self, config, nested_subquery)
+
+    def process_window_frame(self, frame: WindowFrame, config: SqlToStringConfig) -> str:
+        return window_frame_processor(frame, self, config)
+
+    def process_frame_bound(self, frame_bound: FrameBound, config: SqlToStringConfig) -> str:
+        return frame_bound_processor(frame_bound, self, config)

pylegend/core/language/legendql_api/legendql_api_custom_expressions.py

@@ -27,12 +27,14 @@ from pylegend.core.language import (
     PyLegendColumnExpression,
     PyLegendExpressionIntegerReturn,
     PyLegendExpressionFloatReturn,
+    convert_literal_to_literal_expression,
 )
 from pylegend._typing import (
     PyLegendSequence,
     PyLegendOptional,
     PyLegendList,
     PyLegendDict,
+    PyLegendUnion,
 )
 from pylegend.core.language.shared.helpers import escape_column_name
 from pylegend.core.sql.metamodel import (
@@ -44,7 +46,13 @@ from pylegend.core.sql.metamodel import (
     SortItemNullOrdering,
     Window,
     FunctionCall,
-    QualifiedName, IntegerLiteral
+    QualifiedName,
+    IntegerLiteral,
+    WindowFrame,
+    WindowFrameMode,
+    FrameBound,
+    FrameBoundType,
+    StringLiteral
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig, FrameToPureConfig
 from typing import TYPE_CHECKING
@@ -64,6 +72,11 @@ __all__: PyLegendSequence[str] = [
     "LegendQLApiWindow",
     "LegendQLApiPartialFrame",
     "LegendQLApiWindowReference",
+    "LegendQLApiWindowFrameBound",
+    "LegendQLApiWindowFrameMode",
+    "LegendQLApiWindowFrame",
+    "LegendQLApiDurationUnit",
+    "LegendQLApiWindowFrameBoundType"
 ]
 
 
@@ -168,8 +181,174 @@ class LegendQLApiSortInfo:
         return f"{func}(~{escape_column_name(self.__column)})"
 
 
-class LegendQLApiWindowFrame(metaclass=ABCMeta):
-    pass
+class LegendQLApiWindowFrameMode(Enum):
+    ROWS = 1
+    RANGE = 2
+
+
+class LegendQLApiWindowFrameBoundType(Enum):
+    UNBOUNDED_PRECEDING = 1
+    PRECEDING = 2
+    CURRENT_ROW = 3
+    FOLLOWING = 4
+    UNBOUNDED_FOLLOWING = 5
+
+    def to_sql_node(
+            self,
+            query: QuerySpecification,
+            config: FrameToSqlConfig,
+    ) -> FrameBoundType:
+        mapping = {
+            LegendQLApiWindowFrameBoundType.UNBOUNDED_PRECEDING: FrameBoundType.UNBOUNDED_PRECEDING,
+            LegendQLApiWindowFrameBoundType.PRECEDING: FrameBoundType.PRECEDING,
+            LegendQLApiWindowFrameBoundType.CURRENT_ROW: FrameBoundType.CURRENT_ROW,
+            LegendQLApiWindowFrameBoundType.FOLLOWING: FrameBoundType.FOLLOWING,
+            LegendQLApiWindowFrameBoundType.UNBOUNDED_FOLLOWING: FrameBoundType.UNBOUNDED_FOLLOWING
+        }
+
+        return mapping[self]
+
+
+class LegendQLApiDurationUnit(Enum):
+    YEARS = 1
+    MONTHS = 2
+    WEEKS = 3
+    DAYS = 4
+    HOURS = 5
+    MINUTES = 6
+    SECONDS = 7
+    MILLISECONDS = 8
+    MICROSECONDS = 9
+    NANOSECONDS = 10
+
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return self.name
+
+    def to_sql_node(
+            self,
+            query: QuerySpecification,
+            config: FrameToSqlConfig
+    ) -> StringLiteral:
+        mapping = {
+            LegendQLApiDurationUnit.YEARS: "YEAR",
+            LegendQLApiDurationUnit.MONTHS: "MONTH",
+            LegendQLApiDurationUnit.WEEKS: "WEEK",
+            LegendQLApiDurationUnit.DAYS: "DAY",
+            LegendQLApiDurationUnit.HOURS: "HOUR",
+            LegendQLApiDurationUnit.MINUTES: "MINUTE",
+            LegendQLApiDurationUnit.SECONDS: "SECOND",
+            LegendQLApiDurationUnit.MILLISECONDS: "MILLISECOND",
+            LegendQLApiDurationUnit.MICROSECONDS: "MICROSECOND",
+            LegendQLApiDurationUnit.NANOSECONDS: "NANOSECOND",
+        }
+
+        return StringLiteral(mapping[self], quoted=False)
+
+    @classmethod
+    def from_string(cls, value: str) -> "LegendQLApiDurationUnit":
+        try:
+            return cls[value.upper()]
+        except KeyError:
+            raise ValueError(
+                f"Invalid duration unit '{value}'. "
+                f"Supported values: {[u.name.lower() for u in cls]}"
+            )
+
+
+class LegendQLApiWindowFrameBound:
+    __bound_type: LegendQLApiWindowFrameBoundType
+    __row_offset: PyLegendOptional[PyLegendUnion[int, float]]
+    __duration_unit: PyLegendOptional[LegendQLApiDurationUnit]
+
+    def __init__(
+            self,
+            bound_type: LegendQLApiWindowFrameBoundType,
+            row_offset: PyLegendOptional[PyLegendUnion[int, float]] = None,
+            duration_unit: PyLegendOptional[LegendQLApiDurationUnit] = None,
+    ) -> None:
+        if bound_type in (
+                LegendQLApiWindowFrameBoundType.PRECEDING,
+                LegendQLApiWindowFrameBoundType.FOLLOWING,
+        ) and row_offset is None:
+            raise ValueError(f"row_offset must be provided for bound_type {bound_type.name}")
+
+        if bound_type not in (
+                LegendQLApiWindowFrameBoundType.PRECEDING,
+                LegendQLApiWindowFrameBoundType.FOLLOWING,
+        ) and row_offset is not None:
+            raise ValueError(f"row_offset is not allowed for bound_type {bound_type.name}")
+
+        self.__bound_type = bound_type
+        self.__row_offset = row_offset
+        self.__duration_unit = duration_unit
+
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        if (self.__bound_type == LegendQLApiWindowFrameBoundType.UNBOUNDED_FOLLOWING
+                or self.__bound_type == LegendQLApiWindowFrameBoundType.UNBOUNDED_PRECEDING):
+            return "unbounded()"
+
+        elif self.__bound_type == LegendQLApiWindowFrameBoundType.CURRENT_ROW:
+            expr = "0"
+
+        else:
+            expr = convert_literal_to_literal_expression(self.__row_offset).to_pure_expression(
+                config) if self.__row_offset is not None else ""
+
+        if self.__duration_unit is not None:
+            expr += f", DurationUnit.{self.__duration_unit.to_pure_expression(config)}"
+
+        return expr
+
+    def to_sql_node(
+            self,
+            query: QuerySpecification,
+            config: FrameToSqlConfig,
+    ) -> FrameBound:
+        value = (convert_literal_to_literal_expression(abs(self.__row_offset))
+                 .to_sql_expression({"w": query}, config)) \
+            if self.__row_offset is not None else None
+
+        frame_bound_type = self.__bound_type.to_sql_node(query, config)
+
+        duration_unit = self.__duration_unit.to_sql_node(
+            query,
+            config) if self.__duration_unit is not None else None
+
+        return FrameBound(frame_bound_type, value, duration_unit)
+
+
+class LegendQLApiWindowFrame:
+    __mode: LegendQLApiWindowFrameMode
+    __start_bound: LegendQLApiWindowFrameBound
+    __end_bound: LegendQLApiWindowFrameBound
+
+    def __init__(
+            self,
+            mode: LegendQLApiWindowFrameMode,
+            start_bound: LegendQLApiWindowFrameBound,
+            end_bound: LegendQLApiWindowFrameBound,
+    ) -> None:
+        self.__mode = mode
+        self.__start_bound = start_bound
+        self.__end_bound = end_bound
+
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        mode_str = "rows" if self.__mode == LegendQLApiWindowFrameMode.ROWS else "_range"
+        start_expr = self.__start_bound.to_pure_expression(config)
+        end_expr = self.__end_bound.to_pure_expression(config)
+
+        return f"{mode_str}({start_expr}, {end_expr})"
+
+    def to_sql_node(
+            self,
+            query: QuerySpecification,
+            config: FrameToSqlConfig
+    ) -> WindowFrame:
+        return WindowFrame(
+            mode=WindowFrameMode.ROWS if self.__mode == LegendQLApiWindowFrameMode.ROWS else WindowFrameMode.RANGE,
+            start=self.__start_bound.to_sql_node(query, config),
+            end=self.__end_bound.to_sql_node(query, config),
+        )
 
 
 class LegendQLApiWindow:
@@ -211,7 +390,10 @@ class LegendQLApiWindow:
                 [] if self.__order_by is None else
                 [sort_info.to_sql_node(query, config) for sort_info in self.__order_by]
             ),
-            windowFrame=None
+            windowFrame=(
+                None if self.__frame is None else
+                self.__frame.to_sql_node(query, config)
+            ),
         )
 
     @staticmethod
@@ -235,7 +417,10 @@ class LegendQLApiWindow:
             "[]" if self.__order_by is None or len(self.__order_by) == 0
             else "[" + (', '.join([s.to_pure_expression(config) for s in self.__order_by])) + "]"
         )
-        return f"over({partitions_str}, {sorts_str})"
+
+        frame_str = f", {self.__frame.to_pure_expression(config)}" if self.__frame else ""
+
+        return f"over({partitions_str}, {sorts_str}{frame_str})"
 
 
 class LegendQLApiPartialFrame:

pylegend/core/language/pandas_api/pandas_api_series.py

@@ -77,6 +77,9 @@ class Series(PyLegendColumnExpression, PyLegendPrimitive, BaseTdsFrame):
     def value(self) -> PyLegendColumnExpression:
         return self
 
+    def get_base_frame(self) -> "PandasApiTdsFrame":
+        return self.__base_frame
+
     def to_sql_expression(
             self,
             frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],

pylegend/core/sql/metamodel.py

@@ -918,12 +918,15 @@ class WindowFrame(Node):
 class FrameBound(Node):
     type_: "FrameBoundType"
     value: "PyLegendOptional[Expression]"
+    duration_unit: "PyLegendOptional[StringLiteral]"
 
     def __init__(
         self,
         type_: "FrameBoundType",
-        value: "PyLegendOptional[Expression]"
+        value: "PyLegendOptional[Expression]",
+        duration_unit: "PyLegendOptional[StringLiteral]" = None
     ) -> None:
         super().__init__(_type="frameBound")
         self.type_ = type_
         self.value = value
+        self.duration_unit = duration_unit

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

@@ -14,7 +14,10 @@
 
 from pylegend._typing import (
     PyLegendList,
-    PyLegendSequence
+    PyLegendSequence,
+    PyLegendUnion,
+    PyLegendOptional,
+    PyLegendCallable
 )
 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
@@ -25,7 +28,10 @@ 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.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.language.shared.helpers import escape_column_name
 
 __all__: PyLegendSequence[str] = [
     "LegendQLApiDistinctFunction"
@@ -34,27 +40,56 @@ __all__: PyLegendSequence[str] = [
 
 class LegendQLApiDistinctFunction(LegendQLApiAppliedFunction):
     __base_frame: LegendQLApiBaseTdsFrame
+    __column_name_list: PyLegendOptional[PyLegendList[str]]
 
     @classmethod
     def name(cls) -> str:
         return "distinct"
 
-    def __init__(self, base_frame: LegendQLApiBaseTdsFrame) -> None:
+    def __init__(
+            self,
+            base_frame: LegendQLApiBaseTdsFrame,
+            columns: PyLegendOptional[PyLegendUnion[
+                str,
+                PyLegendList[str],
+                PyLegendCallable[
+                    [LegendQLApiTdsRow],
+                    PyLegendUnion[LegendQLApiPrimitive, PyLegendList[LegendQLApiPrimitive]]
+                ]
+            ]] = None
+    ) -> None:
         self.__base_frame = base_frame
+        self.__column_name_list = infer_columns_from_frame(base_frame, columns,
+                                                           "'distinct' function 'columns'") if columns is not None else None
 
     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)
+        should_create_sub_query = (base_query.offset is not None) or (base_query.limit is not None) or (
+                self.__column_name_list is not None)
+
+        quoted_columns = None
+        if self.__column_name_list is not None:
+            db_extension = config.sql_to_string_generator().get_db_extension()
+            quoted_columns = [
+                db_extension.quote_identifier(col)
+                for col in self.__column_name_list
+            ]
+
         new_query = (
-            create_sub_query(base_query, config, "root") if should_create_sub_query else
+            create_sub_query(base_query, config, "root", quoted_columns) if should_create_sub_query else
             copy_query(base_query)
         )
         new_query.select.distinct = True
+
         return new_query
 
     def to_pure(self, config: FrameToPureConfig) -> str:
+        columns_expr = (
+            f"~[{', '.join(map(escape_column_name, self.__column_name_list))}]"
+            if self.__column_name_list else ""
+        )
         return (f"{self.__base_frame.to_pure(config)}{config.separator(1)}"
-                f"->distinct()")
+                f"->distinct({columns_expr})")
 
     def base_frame(self) -> LegendQLApiBaseTdsFrame:
         return self.__base_frame
@@ -63,7 +98,18 @@ class LegendQLApiDistinctFunction(LegendQLApiAppliedFunction):
         return []
 
     def calculate_columns(self) -> PyLegendSequence[TdsColumn]:
-        return [c.copy() for c in self.__base_frame.columns()]
+        if not self.__column_name_list:
+            return [c.copy() for c in self.__base_frame.columns()]
+
+        base_columns = self.__base_frame.columns()
+        new_columns = []
+        for name in self.__column_name_list:
+            for col in base_columns:
+                if col.get_name() == name:
+                    new_columns.append(col.copy())
+                    break
+
+        return new_columns
 
     def validate(self) -> bool:
         return True

pylegend/core/tds/legendql_api/frames/legendql_api_base_tds_frame.py

@@ -30,6 +30,11 @@ from pylegend.core.language.legendql_api.legendql_api_custom_expressions import
     LegendQLApiWindow,
     LegendQLApiPartialFrame,
     LegendQLApiWindowReference,
+    LegendQLApiWindowFrame,
+    LegendQLApiWindowFrameMode,
+    LegendQLApiWindowFrameBound,
+    LegendQLApiWindowFrameBoundType,
+    LegendQLApiDurationUnit
 )
 from pylegend.core.language.legendql_api.legendql_api_tds_row import LegendQLApiTdsRow
 from pylegend.core.tds.abstract.frames.base_tds_frame import BaseTdsFrame
@@ -59,14 +64,23 @@ class LegendQLApiBaseTdsFrame(LegendQLApiTdsFrame, BaseTdsFrame, metaclass=ABCMe
     def limit(self, row_count: int = 5) -> "LegendQLApiTdsFrame":
         return self.head(row_count=row_count)
 
-    def distinct(self) -> "LegendQLApiTdsFrame":
+    def distinct(
+            self,
+            columns: PyLegendOptional[PyLegendUnion[
+                str,
+                PyLegendList[str],
+                PyLegendCallable[
+                    [LegendQLApiTdsRow],
+                    PyLegendUnion[LegendQLApiPrimitive, PyLegendList[LegendQLApiPrimitive]]
+                ]
+            ]] = None) -> "LegendQLApiTdsFrame":
         from pylegend.core.tds.legendql_api.frames.legendql_api_applied_function_tds_frame import (
             LegendQLApiAppliedFunctionTdsFrame
         )
         from pylegend.core.tds.legendql_api.frames.functions.legendql_api_distinct_function import (
             LegendQLApiDistinctFunction
         )
-        return LegendQLApiAppliedFunctionTdsFrame(LegendQLApiDistinctFunction(self))
+        return LegendQLApiAppliedFunctionTdsFrame(LegendQLApiDistinctFunction(self, columns))
 
     def select(
             self,
@@ -304,6 +318,80 @@ class LegendQLApiBaseTdsFrame(LegendQLApiTdsFrame, BaseTdsFrame, metaclass=ABCMe
             LegendQLApiGroupByFunction(self, grouping_columns, aggregate_specifications)
         )
 
+    def rows(
+            self,
+            start: PyLegendUnion[str, int],
+            end: PyLegendUnion[str, int]) -> LegendQLApiWindowFrame:
+        return LegendQLApiWindowFrame(
+            LegendQLApiWindowFrameMode.ROWS,
+            _infer_window_frame_bound(start, is_start_bound=True),
+            _infer_window_frame_bound(end)
+        )
+
+    def range(
+            self,
+            *,
+            number_start: PyLegendOptional[PyLegendUnion[str, int, float]] = None,
+            number_end: PyLegendOptional[PyLegendUnion[str, int, float]] = None,
+            duration_start: PyLegendOptional[PyLegendUnion[str, int, float]] = None,
+            duration_start_unit: PyLegendOptional[str] = None,
+            duration_end: PyLegendOptional[PyLegendUnion[str, int, float]] = None,
+            duration_end_unit: PyLegendOptional[str] = None) -> LegendQLApiWindowFrame:
+
+        has_number = number_start is not None or number_end is not None
+        has_duration = any([
+            duration_start is not None,
+            duration_end is not None,
+            duration_start_unit is not None,
+            duration_end_unit is not None,
+        ])
+
+        if not has_number and not has_duration:
+            raise ValueError(
+                "Either numeric range or duration range must be provided. "
+                "Specify number_start and number_end, or duration_start and duration_end "
+                "(with duration_start_unit and duration_end_unit as needed)."
+            )
+
+        if has_number and has_duration:
+            raise ValueError(
+                "Numeric range and duration range cannot be used together. "
+                "Use either (number_start, number_end) or (duration_start, duration_end)."
+                "(with duration_start_unit and duration_end_unit as needed)."
+            )
+
+        if has_number:
+            if number_start is None or number_end is None:
+                raise ValueError(
+                    "Both number_start and number_end must be provided together."
+                )
+
+            return LegendQLApiWindowFrame(
+                LegendQLApiWindowFrameMode.RANGE,
+                _infer_window_frame_bound(number_start, is_start_bound=True),
+                _infer_window_frame_bound(number_end),
+            )
+
+        if duration_start is None or duration_end is None:
+            raise ValueError(
+                "Both duration_start and duration_end must be provided."
+                "(with duration_start_unit and duration_end_unit as needed).")
+
+        def is_unbounded(value: object) -> bool:
+            return isinstance(value, str) and value.lower() == "unbounded"
+
+        if not is_unbounded(duration_start) and duration_start_unit is None:
+            raise ValueError("duration_start_unit is required for bounded duration_start.")
+
+        if not is_unbounded(duration_end) and duration_end_unit is None:
+            raise ValueError("duration_end_unit is required for bounded duration_end.")
+
+        return LegendQLApiWindowFrame(
+            LegendQLApiWindowFrameMode.RANGE,
+            _infer_window_frame_bound(duration_start, is_start_bound=True, duration_unit=duration_start_unit),
+            _infer_window_frame_bound(duration_end, duration_unit=duration_end_unit)
+        )
+
     def window(
             self,
             partition_by: PyLegendOptional[
@@ -329,7 +417,8 @@ class LegendQLApiBaseTdsFrame(LegendQLApiTdsFrame, BaseTdsFrame, metaclass=ABCMe
                         ]
                     ]
                 ]
-            ] = None
+            ] = None,
+            frame: PyLegendOptional[LegendQLApiWindowFrame] = None
     ) -> "LegendQLApiWindow":
         from pylegend.core.tds.legendql_api.frames.functions.legendql_api_function_helpers import (
             infer_columns_from_frame,
@@ -344,7 +433,7 @@ class LegendQLApiBaseTdsFrame(LegendQLApiTdsFrame, BaseTdsFrame, metaclass=ABCMe
                 None if order_by is None else
                 infer_sorts_from_frame(self, order_by, "'window' function order_by")
             ),
-            frame=None
+            frame=frame
         )
 
     def window_extend(
@@ -417,3 +506,56 @@ class LegendQLApiBaseTdsFrame(LegendQLApiTdsFrame, BaseTdsFrame, metaclass=ABCMe
             LegendQLApiProjectFunction
         )
         return LegendQLApiAppliedFunctionTdsFrame(LegendQLApiProjectFunction(self, project_columns))
+
+
+def _infer_window_frame_bound(
+        value: PyLegendOptional[
+            PyLegendUnion[str, int, float]
+        ] = None,
+        *,
+        is_start_bound: bool = False,
+        duration_unit: PyLegendOptional[str] = None,
+) -> LegendQLApiWindowFrameBound:
+    if isinstance(value, str):
+        if value.lower() != "unbounded":
+            raise ValueError(
+                f"Invalid window frame boundary '{value}'. "
+                "Only 'unbounded' is supported as a string. "
+                "Otherwise, provide a numeric offset where "
+                "positive = FOLLOWING, negative = PRECEDING, "
+                "and 0 = CURRENT ROW."
+            )
+
+        bound_type = (
+            LegendQLApiWindowFrameBoundType.UNBOUNDED_PRECEDING
+            if is_start_bound
+            else LegendQLApiWindowFrameBoundType.UNBOUNDED_FOLLOWING
+        )
+
+        return LegendQLApiWindowFrameBound(bound_type)
+
+    if not isinstance(value, (int, float)):
+        raise TypeError(
+            f"Invalid type for window frame boundary: {type(value).__name__}. "
+            "Expected 'unbounded' (str) or numeric offset (int | float)."
+        )
+
+    duration_unit_enum = (
+        LegendQLApiDurationUnit.from_string(duration_unit)
+        if duration_unit
+        else None
+    )
+
+    if value == 0:
+        return LegendQLApiWindowFrameBound(
+            LegendQLApiWindowFrameBoundType.CURRENT_ROW,
+            row_offset=None,
+            duration_unit=duration_unit_enum
+        )
+
+    if value > 0:
+        bound_type = LegendQLApiWindowFrameBoundType.FOLLOWING
+    else:
+        bound_type = LegendQLApiWindowFrameBoundType.PRECEDING
+
+    return LegendQLApiWindowFrameBound(bound_type, value, duration_unit_enum)