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

pylegend/core/language/shared/primitives/integer.py

@@ -33,7 +33,13 @@ from pylegend.core.language.shared.operations.integer_operation_expressions impo
     PyLegendIntegerSubtractExpression,
     PyLegendIntegerMultiplyExpression,
     PyLegendIntegerModuloExpression,
-    PyLegendIntegerCharExpression
+    PyLegendIntegerCharExpression,
+    PyLegendIntegerBitAndExpression,
+    PyLegendIntegerBitOrExpression,
+    PyLegendIntegerBitXorExpression,
+    PyLegendIntegerBitShiftLeftExpression,
+    PyLegendIntegerBitShiftRightExpression,
+    PyLegendIntegerBitNotExpression
 )
 if TYPE_CHECKING:
     from pylegend.core.language.shared.primitives import PyLegendFloat
@@ -159,6 +165,53 @@ class PyLegendInteger(PyLegendNumber):
     def __pos__(self) -> "PyLegendInteger":
         return self
 
+    def __invert__(self) -> "PyLegendInteger":
+        return PyLegendInteger(PyLegendIntegerBitNotExpression(self.__value_copy))
+
+    def __and__(self, other: PyLegendUnion[int, "PyLegendInteger"]) -> "PyLegendInteger":
+        return self._create_binary_expression(other, PyLegendIntegerBitAndExpression, "and (&)")
+
+    def __rand__(self, other: PyLegendUnion[int, "PyLegendInteger"]) -> "PyLegendInteger":
+        return self._create_binary_expression(other, PyLegendIntegerBitAndExpression, "and (&)", reverse=True)
+
+    def __or__(self, other: PyLegendUnion[int, "PyLegendInteger"]) -> "PyLegendInteger":
+        return self._create_binary_expression(other, PyLegendIntegerBitOrExpression, "or (|)")
+
+    def __ror__(self, other: PyLegendUnion[int, "PyLegendInteger"]) -> "PyLegendInteger":
+        return self._create_binary_expression(other, PyLegendIntegerBitOrExpression, "or (|)", reverse=True)
+
+    def __xor__(self, other: PyLegendUnion[int, "PyLegendInteger"]) -> "PyLegendInteger":
+        return self._create_binary_expression(other, PyLegendIntegerBitXorExpression, "xor (^)")
+
+    def __rxor__(self, other: PyLegendUnion[int, "PyLegendInteger"]) -> "PyLegendInteger":
+        return self._create_binary_expression(other, PyLegendIntegerBitXorExpression, "xor (^)", reverse=True)
+
+    def __lshift__(self, other: PyLegendUnion[int, "PyLegendInteger"]) -> "PyLegendInteger":
+        return self._create_binary_expression(other, PyLegendIntegerBitShiftLeftExpression, "left shift (<<)")
+
+    def __rlshift__(self, other: PyLegendUnion[int, "PyLegendInteger"]) -> "PyLegendInteger":
+        return self._create_binary_expression(other, PyLegendIntegerBitShiftLeftExpression, "left shift (<<)", reverse=True)
+
+    def __rshift__(self, other: PyLegendUnion[int, "PyLegendInteger"]) -> "PyLegendInteger":
+        return self._create_binary_expression(other, PyLegendIntegerBitShiftRightExpression, "right shift (>>)")
+
+    def __rrshift__(self, other: PyLegendUnion[int, "PyLegendInteger"]) -> "PyLegendInteger":
+        return self._create_binary_expression(other, PyLegendIntegerBitShiftRightExpression, "right shift (>>)", reverse=True)
+
+    def _create_binary_expression(
+            self,
+            other: PyLegendUnion[int, "PyLegendInteger"],
+            expression_class: type,
+            operation_name: str,
+            reverse: bool = False
+    ) -> "PyLegendInteger":
+        PyLegendInteger.__validate__param_to_be_integer(other, f"Integer {operation_name} parameter")
+        other_op = PyLegendInteger.__convert_to_integer_expr(other)
+
+        if reverse:
+            return PyLegendInteger(expression_class(other_op, self.__value_copy))
+        return PyLegendInteger(expression_class(self.__value_copy, other_op))
+
     @staticmethod
     def __convert_to_integer_expr(
             val: PyLegendUnion[int, "PyLegendInteger"]

pylegend/core/language/shared/primitives/strictdate.py

@@ -24,13 +24,16 @@ from pylegend.core.language.shared.expression import (
 )
 from pylegend.core.language.shared.literal_expressions import (
     PyLegendStrictDateLiteralExpression,
+    PyLegendIntegerLiteralExpression,
+    PyLegendStringLiteralExpression
 )
 from pylegend.core.sql.metamodel import (
     Expression,
     QuerySpecification
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
-
+from pylegend.core.language.shared.operations.date_operation_expressions import PyLegendDateTimeBucketExpression
+from pylegend.core.language.shared.primitives.integer import PyLegendInteger
 
 __all__: PyLegendSequence[str] = [
     "PyLegendStrictDate"
@@ -57,6 +60,20 @@ class PyLegendStrictDate(PyLegendDate):
     def value(self) -> PyLegendExpressionStrictDateReturn:
         return self.__value
 
+    def time_bucket(
+            self,
+            quantity: PyLegendUnion[int, "PyLegendInteger"],
+            duration_unit: str) -> "PyLegendDate":
+        self.validate_param_to_be_int_or_int_expr(quantity, "time bucket quantity parameter")
+        quantity_op = PyLegendIntegerLiteralExpression(quantity) if isinstance(quantity, int) else quantity.value()
+        self.validate_duration_unit_param(duration_unit)
+        duration_unit_op = PyLegendStringLiteralExpression(duration_unit.upper())
+        return PyLegendDate(PyLegendDateTimeBucketExpression([
+            self.__value,
+            quantity_op,
+            duration_unit_op,
+            PyLegendStringLiteralExpression("STRICTDATE")]))
+
     @staticmethod
     def __convert_to_strictdate_expr(
             val: PyLegendUnion[date, "PyLegendStrictDate"]
@@ -73,3 +90,10 @@ class PyLegendStrictDate(PyLegendDate):
         if not isinstance(param, (date, PyLegendStrictDate)):
             raise TypeError(desc + " should be a datetime.date or a StrictDate expression (PyLegendStrictDate)."
                                    " Got value " + str(param) + " of type: " + str(type(param)))
+
+    @staticmethod
+    def validate_duration_unit_param(duration_unit: str) -> None:
+        if duration_unit.lower() not in ('years', 'months', 'weeks', 'days'):
+            raise ValueError(
+                f"Unknown duration unit - {duration_unit}. Supported values are - YEARS, MONTHS, WEEKS, DAYS"
+            )

pylegend/core/language/shared/primitives/string.py

@@ -18,7 +18,10 @@ from pylegend._typing import (
     PyLegendUnion,
     PyLegendOptional
 )
-from pylegend.core.language.shared.literal_expressions import PyLegendIntegerLiteralExpression
+from pylegend.core.language.shared.literal_expressions import (
+    PyLegendIntegerLiteralExpression,
+    convert_literal_to_literal_expression
+)
 from pylegend.core.language.shared.primitives.primitive import PyLegendPrimitive
 from pylegend.core.language.shared.primitives.integer import PyLegendInteger
 from pylegend.core.language.shared.primitives.float import PyLegendFloat
@@ -67,7 +70,8 @@ from pylegend.core.language.shared.operations.string_operation_expressions impor
     PyLegendStringSplitPartExpression,
     PyLegendStringFullMatchExpression,
     PyLegendStringRepeatStringExpression,
-    PyLegendStringMatchExpression
+    PyLegendStringMatchExpression,
+    PyLegendStringCoalesceExpression
 )
 
 __all__: PyLegendSequence[str] = [
@@ -242,6 +246,16 @@ class PyLegendString(PyLegendPrimitive):
         times_op = PyLegendIntegerLiteralExpression(times) if isinstance(times, int) else times.value()
         return PyLegendString(PyLegendStringRepeatStringExpression(self.__value, times_op))
 
+    def coalesce(self, *other: PyLegendOptional[PyLegendUnion[str, "PyLegendString"]]) -> "PyLegendString":
+        other_op = []
+        for op in other:
+            if op is not None:
+                PyLegendString.__validate_param_to_be_str_or_str_expr(op, "coalesce parameter")
+            other_op.append(
+                convert_literal_to_literal_expression(op) if not isinstance(op, PyLegendString) else op.__value)
+
+        return PyLegendString(PyLegendStringCoalesceExpression([self.__value, *other_op]))
+
     def __add__(self, other: PyLegendUnion[str, "PyLegendString"]) -> "PyLegendString":
         PyLegendString.__validate_param_to_be_str_or_str_expr(other, "String plus (+) parameter")
         other_op = PyLegendStringLiteralExpression(other) if isinstance(other, str) else other.__value

pylegend/core/sql/metamodel.py

@@ -87,7 +87,11 @@ __all__: PyLegendSequence[str] = [
     'InPredicate',
     'Window',
     'WindowFrame',
-    'FrameBound'
+    'FrameBound',
+    'BitwiseShiftDirection',
+    'BitwiseBinaryOperator',
+    'BitwiseBinaryExpression',
+    'BitwiseShiftExpression',
 ]
 
 
@@ -179,6 +183,17 @@ class ExtractField(Enum):
     EPOCH = 17
 
 
+class BitwiseShiftDirection(Enum):
+    LEFT = 1
+    RIGHT = 2
+
+
+class BitwiseBinaryOperator(Enum):
+    AND = 1
+    OR = 2
+    XOR = 3
+
+
 class Node:
     _type: str
 
@@ -918,12 +933,49 @@ 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
+
+
+class BitwiseBinaryExpression(Expression):
+    left: "Expression"
+    right: "Expression"
+    operator: "BitwiseBinaryOperator"
+
+    def __init__(
+            self,
+            left: "Expression",
+            right: "Expression",
+            operator: "BitwiseBinaryOperator"
+    ) -> None:
+        super().__init__(_type="bitwiseBinaryExpression")
+        self.left = left
+        self.right = right
+        self.operator = operator
+
+
+class BitwiseShiftExpression(Expression):
+    value: "Expression"
+    shift: "Expression"
+    direction: "BitwiseShiftDirection"
+
+    def __init__(
+            self,
+            value: "Expression",
+            shift: "Expression",
+            direction: "BitwiseShiftDirection"
+    ) -> None:
+        super().__init__(_type="bitwiseShiftExpression")
+        self.value = value
+        self.shift = shift
+        self.direction = direction

pylegend/core/sql/metamodel_extension.py

@@ -20,6 +20,7 @@ from pylegend._typing import (
 from pylegend.core.sql.metamodel import (
     Expression,
     Window,
+    StringLiteral,
 )
 
 __all__: PyLegendSequence[str] = [
@@ -81,7 +82,12 @@ __all__: PyLegendSequence[str] = [
     "EpochExpression",
     "WindowExpression",
     "ConstantExpression",
-    "StringSubStringExpression"
+    "StringSubStringExpression",
+    "DateAdjustExpression",
+    "BitwiseNotExpression",
+    "DateDiffExpression",
+    "DateTimeBucketExpression",
+    "DateType"
 ]
 
 
@@ -763,3 +769,73 @@ class StringSubStringExpression(Expression):
         self.value = value
         self.start = start
         self.end = end
+
+
+class DateAdjustExpression(Expression):
+    date: "Expression"
+    number: "Expression"
+    duration_unit: "StringLiteral"
+
+    def __init__(
+            self,
+            date: "Expression",
+            number: "Expression",
+            duration_unit: "StringLiteral",
+    ) -> None:
+        super().__init__(_type="dateAdjustExpression")
+        self.date = date
+        self.number = number
+        self.duration_unit = duration_unit
+
+
+class DateDiffExpression(Expression):
+    start_date: "Expression"
+    end_date: "Expression"
+    duration_unit: "StringLiteral"
+
+    def __init__(
+            self,
+            start_date: "Expression",
+            end_date: "Expression",
+            duration_unit: "StringLiteral",
+    ) -> None:
+        super().__init__(_type="dateDiffExpression")
+        self.start_date = start_date
+        self.end_date = end_date
+        self.duration_unit = duration_unit
+
+
+class DateType(Enum):
+    DateTime = 1
+    StrictDate = 2
+
+
+class DateTimeBucketExpression(Expression):
+    date: "Expression"
+    quantity: "Expression"
+    duration_unit: "StringLiteral"
+    date_type: DateType
+
+    def __init__(
+            self,
+            date: "Expression",
+            quantity: "Expression",
+            duration_unit: "StringLiteral",
+            date_type: DateType = DateType.DateTime,
+    ) -> None:
+        super().__init__(_type="dateTimeBucketExpression")
+        self.date = date
+        self.quantity = quantity
+        self.duration_unit = duration_unit
+        self.date_type = date_type
+
+
+class BitwiseNotExpression(Expression):
+    value: "Expression"
+
+    def __init__(
+            self,
+            value: "Expression",
+    ) -> None:
+        super().__init__(_type="bitwiseNotExpression")
+        self.value = value

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)