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

pylegend/core/database/sql_to_string/db_extension.py

@@ -72,6 +72,14 @@ from pylegend.core.sql.metamodel import (
     Window,
     TableFunction,
     Union,
+    WindowFrame,
+    WindowFrameMode,
+    FrameBound,
+    FrameBoundType,
+    BitwiseShiftExpression,
+    BitwiseShiftDirection,
+    BitwiseBinaryExpression,
+    BitwiseBinaryOperator
 )
 from pylegend.core.sql.metamodel_extension import (
     StringLengthExpression,
@@ -133,6 +141,11 @@ from pylegend.core.sql.metamodel_extension import (
     WindowExpression,
     ConstantExpression,
     StringSubStringExpression,
+    DateAdjustExpression,
+    BitwiseNotExpression,
+    DateDiffExpression,
+    DateTimeBucketExpression,
+    DateType,
 )
 
 __all__: PyLegendSequence[str] = [
@@ -456,6 +469,18 @@ def expression_processor(
         return expression.name
     elif isinstance(expression, StringSubStringExpression):
         return extension.process_string_substring_expression(expression, config)
+    elif isinstance(expression, DateAdjustExpression):
+        return extension.process_date_adjust_expression(expression, config)
+    elif isinstance(expression, DateDiffExpression):
+        return extension.process_date_diff_expression(expression, config)
+    elif isinstance(expression, DateTimeBucketExpression):
+        return extension.process_date_time_bucket_expression(expression, config)
+    elif isinstance(expression, BitwiseNotExpression):
+        return extension.process_bitwise_not_expression(expression, config)
+    elif isinstance(expression, BitwiseShiftExpression):
+        return extension.process_bitwise_shift_expression(expression, config)
+    elif isinstance(expression, BitwiseBinaryExpression):
+        return extension.process_bitwise_binary_expression(expression, config)
 
     else:
         raise ValueError("Unsupported expression type: " + str(type(expression)))  # pragma: no cover
@@ -516,6 +541,139 @@ def logical_binary_expression_processor(
     return f"({left} {op} {right})"
 
 
+def bitwise_binary_expression_processor(
+        bitwise: BitwiseBinaryExpression,
+        extension: "SqlToStringDbExtension",
+        config: SqlToStringConfig
+) -> str:
+    op_type = bitwise.operator
+    if op_type == BitwiseBinaryOperator.AND:
+        op = "&"
+    elif op_type == BitwiseBinaryOperator.OR:
+        op = "|"
+    elif op_type == BitwiseBinaryOperator.XOR:
+        op = "#"
+    else:
+        raise ValueError("Unknown bitwise binary operator type: " + str(op_type))  # pragma: no cover
+
+    left = extension.process_expression(bitwise.left, config)
+    right = extension.process_expression(bitwise.right, config)
+    return f"({left} {op} {right})"
+
+
+def date_diff_processor(
+        date_diff: DateDiffExpression,
+        extension: "SqlToStringDbExtension",
+        config: SqlToStringConfig
+) -> str:
+    unit = date_diff.duration_unit.value
+
+    end = extension.process_expression(date_diff.end_date, config)
+    start = extension.process_expression(date_diff.start_date, config)
+
+    def extract_diff(part: str) -> str:
+        return f"(EXTRACT({part} FROM {end}) - EXTRACT({part} FROM {start}))"
+
+    year_diff = extract_diff("YEAR")
+    month_diff = extract_diff("MONTH")
+    # d1 - d2 → Pure dateDiff(d1, d2) → evaluated as d2 - d1
+    # Reverse to preserve expected semantics.
+    # only for days
+    day_diff = f"CAST(CAST({start} AS DATE) - CAST({end} AS DATE) AS INTEGER)"
+    epoch_diff = f"(EXTRACT(EPOCH FROM {end}) - EXTRACT(EPOCH FROM {start}))"
+
+    if unit == "YEARS":
+        return year_diff
+
+    if unit == "MONTHS":
+        return f"({year_diff} * 12 + {month_diff})"
+
+    if unit == "DAYS":
+        return day_diff
+
+    if unit == "WEEKS":
+        return f"CAST(FLOOR({day_diff} / 7) AS INTEGER)"
+
+    if unit == "HOURS":
+        return f"CAST(FLOOR({epoch_diff} / 3600) AS INTEGER)"
+
+    if unit == "MINUTES":
+        return f"CAST(FLOOR({epoch_diff} / 60) AS INTEGER)"
+
+    if unit == "SECONDS":
+        return f"CAST({epoch_diff} AS BIGINT)"
+
+    if unit == "MILLISECONDS":
+        return f"CAST({epoch_diff} * 1000 AS BIGINT)"
+
+    raise ValueError(f"Unsupported DATE DIFF unit: {unit}")  # pragma: no cover
+
+
+def date_time_bucket_processor(
+        expression: DateTimeBucketExpression,
+        extension: "SqlToStringDbExtension",
+        config: SqlToStringConfig
+) -> str:
+    unit = expression.duration_unit.value
+    ts = extension.process_expression(expression.date, config)
+    q = extension.process_expression(expression.quantity, config)
+
+    def coerce_to_datetime(sql: str) -> str:
+        return (
+            f"(({sql}) + INTERVAL '0 second')"
+            if expression.date_type == DateType.DateTime
+            else sql
+        )
+
+    def epoch() -> str:
+        return (
+            f"EXTRACT(EPOCH FROM {ts})"
+        )
+
+    if unit == "YEARS":
+        return coerce_to_datetime(
+            f"make_date(1970,1,1) + "
+            f"(FLOOR((EXTRACT(YEAR FROM {ts}) - 1970) / {q}) * {q}) * INTERVAL '1 year'"
+        )
+
+    if unit == "MONTHS":
+        total_months_sql = f"((EXTRACT(YEAR FROM {ts}) - 1970) * 12 + (EXTRACT(MONTH FROM {ts}) - 1))"
+        return coerce_to_datetime(
+            f"make_date(1970,1,1) + "
+            f"(FLOOR({total_months_sql} / {q}) * {q}) * INTERVAL '1 month'"
+        )
+
+    if unit == "WEEKS":
+        return coerce_to_datetime(
+            f"make_date(1969,12,29) + ("
+            f"FLOOR(("
+            f"{epoch()} - EXTRACT(EPOCH FROM make_date(1969,12,29))"
+            f") / (86400 * {q} * 7))"
+            f") * ({q} * 7) * INTERVAL '1 day'"
+        )
+
+    if unit == "DAYS":
+        days_from_1970 = f"({epoch()} / 86400)"
+        return coerce_to_datetime(
+            f"make_date(1970,1,1) + "
+            f"(FLOOR({days_from_1970} / {q}) * {q}) * INTERVAL '1 day'"
+        )
+
+    unit_seconds_map = {
+        "HOURS": 3600,
+        "MINUTES": 60,
+        "SECONDS": 1
+    }
+
+    if unit in unit_seconds_map:
+        seconds_per_unit = unit_seconds_map[unit]
+        return (f"(make_date(1970,1,1) + "
+                f"(FLOOR({epoch()} / ({q} * {seconds_per_unit})) * ({q} * {seconds_per_unit})) "
+                f"* INTERVAL '1 second')")
+
+    raise ValueError(f"Unsupported TIME BUCKET unit: {unit}")  # pragma: no cover
+
+
 def not_expression_processor(
         not_expression: NotExpression,
         extension: "SqlToStringDbExtension",
@@ -864,14 +1022,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 +1072,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 +1470,31 @@ 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)
+
+    def process_date_adjust_expression(self, expr: DateAdjustExpression, config: SqlToStringConfig) -> str:
+        return (f"({self.process_expression(expr.date, config)}::DATE + "
+                f"(INTERVAL '{self.process_expression(expr.number, config)} "
+                f"{expr.duration_unit.value.upper()}'))::DATE")
+
+    def process_bitwise_not_expression(self, expr: BitwiseNotExpression, config: SqlToStringConfig) -> str:
+        return f"~({self.process_expression(expr.value, config)})"
+
+    def process_bitwise_shift_expression(self, expr: BitwiseShiftExpression, config: SqlToStringConfig) -> str:
+        return (f"({self.process_expression(expr.value, config)} "
+                f"{'>>' if expr.direction == BitwiseShiftDirection.RIGHT else '<<'} "
+                f"{self.process_expression(expr.shift, config)})")
+
+    def process_bitwise_binary_expression(self, expr: BitwiseBinaryExpression, config: SqlToStringConfig) -> str:
+        return bitwise_binary_expression_processor(expr, self, config)
+
+    def process_date_diff_expression(self, expr: DateDiffExpression, config: SqlToStringConfig) -> str:
+        return date_diff_processor(expr, self, config)
+
+    def process_date_time_bucket_expression(self, expr: DateTimeBucketExpression, config: SqlToStringConfig) -> str:
+        return date_time_bucket_processor(expr, 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/language/shared/expression.py

@@ -36,6 +36,7 @@ __all__: PyLegendSequence[str] = [
     "PyLegendExpressionDateReturn",
     "PyLegendExpressionDateTimeReturn",
     "PyLegendExpressionStrictDateReturn",
+    "PyLegendExpressionNullReturn"
 ]
 
 
@@ -86,3 +87,7 @@ class PyLegendExpressionDateTimeReturn(PyLegendExpressionDateReturn, metaclass=A
 
 class PyLegendExpressionStrictDateReturn(PyLegendExpressionDateReturn, metaclass=ABCMeta):
     pass
+
+
+class PyLegendExpressionNullReturn(PyLegendExpression, metaclass=ABCMeta):
+    pass

pylegend/core/language/shared/literal_expressions.py

@@ -27,6 +27,7 @@ from pylegend.core.language.shared.expression import (
     PyLegendExpressionFloatReturn,
     PyLegendExpressionDateTimeReturn,
     PyLegendExpressionStrictDateReturn,
+    PyLegendExpressionNullReturn,
 )
 from pylegend.core.sql.metamodel import (
     Expression,
@@ -37,6 +38,7 @@ from pylegend.core.sql.metamodel import (
     QuerySpecification,
     Cast,
     ColumnType,
+    NullLiteral,
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
 from pylegend.core.tds.tds_frame import FrameToPureConfig
@@ -180,8 +182,25 @@ class PyLegendStrictDateLiteralExpression(PyLegendExpressionStrictDateReturn):
         return True
 
 
+class PyLegendNullLiteralExpression(PyLegendExpressionNullReturn):
+    __value: None
+
+    def __init__(self) -> None:
+        return
+
+    def to_sql_expression(
+            self,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return NullLiteral()
+
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return "[]"
+
+
 def convert_literal_to_literal_expression(
-        literal: PyLegendUnion[int, float, bool, str, datetime, date]
+        literal: PyLegendUnion[int, float, bool, str, datetime, date, None]
 ) -> PyLegendExpression:
     if isinstance(literal, bool):
         return PyLegendBooleanLiteralExpression(literal)
@@ -195,5 +214,7 @@ def convert_literal_to_literal_expression(
         return PyLegendDateTimeLiteralExpression(literal)
     if isinstance(literal, date):
         return PyLegendStrictDateLiteralExpression(literal)
+    if isinstance(literal, type(None)):
+        return PyLegendNullLiteralExpression()
 
     raise TypeError(f"Cannot convert value - {literal} of type {type(literal)} to literal expression")