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

pylegend/core/language/legendql_api/legendql_api_tds_row.py

@@ -0,0 +1,292 @@
+# 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,
+    PyLegendDict,
+)
+from pylegend.core.language import (
+    PyLegendBoolean,
+    PyLegendString,
+    PyLegendInteger,
+    PyLegendFloat,
+    PyLegendNumber,
+    PyLegendStrictDate,
+    PyLegendDateTime,
+    PyLegendDate,
+)
+from pylegend.core.language.legendql_api.legendql_api_custom_expressions import (
+    LegendQLApiBoolean,
+    LegendQLApiString,
+    LegendQLApiInteger,
+    LegendQLApiFloat,
+    LegendQLApiNumber,
+    LegendQLApiStrictDate,
+    LegendQLApiDateTime,
+    LegendQLApiDate,
+    LegendQLApiPrimitive,
+    LegendQLApiPartialFrame,
+    LegendQLApiWindowReference,
+)
+from pylegend.core.language.shared.tds_row import AbstractTdsRow
+from pylegend.core.sql.metamodel import (
+    QuerySpecification,
+    Expression,
+    FunctionCall,
+    QualifiedName,
+    IntegerLiteral
+)
+from pylegend.core.tds.tds_frame import PyLegendTdsFrame, FrameToPureConfig, FrameToSqlConfig
+
+__all__: PyLegendSequence[str] = [
+    "LegendQLApiTdsRow",
+    "LegendQLApiLeadRow",
+    "LegendQLApiLagRow",
+    "LegendQLApiFirstRow",
+    "LegendQLApiLastRow",
+    "LegendQLApiNthRow",
+]
+
+
+class LegendQLApiTdsRow(AbstractTdsRow):
+
+    def __init__(self, frame_name: str, frame: PyLegendTdsFrame) -> None:
+        super().__init__(frame_name, frame)
+
+    @staticmethod
+    def from_tds_frame(frame_name: str, frame: PyLegendTdsFrame) -> "LegendQLApiTdsRow":
+        return LegendQLApiTdsRow(frame_name=frame_name, frame=frame)
+
+    def __getattr__(self, key: str) -> LegendQLApiPrimitive:
+        return self[key]
+
+    def get_boolean(self, column: str) -> LegendQLApiBoolean:
+        return LegendQLApiBoolean(super().get_boolean(column))
+
+    def get_string(self, column: str) -> LegendQLApiString:
+        return LegendQLApiString(super().get_string(column))
+
+    def get_number(self, column: str) -> LegendQLApiNumber:
+        return LegendQLApiNumber(super().get_number(column))
+
+    def get_integer(self, column: str) -> LegendQLApiInteger:
+        return LegendQLApiInteger(super().get_integer(column))
+
+    def get_float(self, column: str) -> LegendQLApiFloat:
+        return LegendQLApiFloat(super().get_float(column))
+
+    def get_date(self, column: str) -> LegendQLApiDate:
+        return LegendQLApiDate(super().get_date(column))
+
+    def get_datetime(self, column: str) -> LegendQLApiDateTime:
+        return LegendQLApiDateTime(super().get_datetime(column))
+
+    def get_strictdate(self, column: str) -> LegendQLApiStrictDate:
+        return LegendQLApiStrictDate(super().get_strictdate(column))
+
+    def __getitem__(self, item: str) -> LegendQLApiPrimitive:
+        res = super().__getitem__(item)
+        if isinstance(res, PyLegendBoolean):
+            return LegendQLApiBoolean(res)
+        if isinstance(res, PyLegendString):
+            return LegendQLApiString(res)
+        if isinstance(res, PyLegendInteger):
+            return LegendQLApiInteger(res)
+        if isinstance(res, PyLegendFloat):
+            return LegendQLApiFloat(res)
+        if isinstance(res, PyLegendNumber):
+            return LegendQLApiNumber(res)
+        if isinstance(res, PyLegendStrictDate):
+            return LegendQLApiStrictDate(res)
+        if isinstance(res, PyLegendDateTime):
+            return LegendQLApiDateTime(res)
+        if isinstance(res, PyLegendDate):
+            return LegendQLApiDate(res)
+
+        raise RuntimeError(f"Unhandled primitive type {type(res)} in LegendQL Api")
+
+
+class LegendQLApiLeadRow(LegendQLApiTdsRow):
+    __partial_frame: LegendQLApiPartialFrame
+    __row: "LegendQLApiTdsRow"
+
+    def __init__(
+            self,
+            partial_frame: LegendQLApiPartialFrame,
+            row: "LegendQLApiTdsRow"
+    ) -> None:
+        super().__init__(frame_name=row.get_frame_name(), frame=partial_frame.get_base_frame())
+        self.__partial_frame = partial_frame
+        self.__row = row
+
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return f"{self.__partial_frame.to_pure_expression(config)}->lead({self.__row.to_pure_expression(config)})"
+
+    def column_sql_expression(
+            self,
+            column: str,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["lead"]),
+            distinct=False,
+            arguments=[super().column_sql_expression(column, frame_name_to_base_query_map, config)],
+            filter_=None,
+            window=None
+        )
+
+
+class LegendQLApiLagRow(LegendQLApiTdsRow):
+    __partial_frame: LegendQLApiPartialFrame
+    __row: "LegendQLApiTdsRow"
+
+    def __init__(
+            self,
+            partial_frame: LegendQLApiPartialFrame,
+            row: "LegendQLApiTdsRow"
+    ) -> None:
+        super().__init__(frame_name=row.get_frame_name(), frame=partial_frame.get_base_frame())
+        self.__partial_frame = partial_frame
+        self.__row = row
+
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return f"{self.__partial_frame.to_pure_expression(config)}->lag({self.__row.to_pure_expression(config)})"
+
+    def column_sql_expression(
+            self,
+            column: str,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["lag"]),
+            distinct=False,
+            arguments=[super().column_sql_expression(column, frame_name_to_base_query_map, config)],
+            filter_=None,
+            window=None
+        )
+
+
+class LegendQLApiFirstRow(LegendQLApiTdsRow):
+    __partial_frame: LegendQLApiPartialFrame
+    __window_ref: LegendQLApiWindowReference
+    __row: "LegendQLApiTdsRow"
+
+    def __init__(
+            self,
+            partial_frame: LegendQLApiPartialFrame,
+            window_ref: LegendQLApiWindowReference,
+            row: "LegendQLApiTdsRow"
+    ) -> None:
+        super().__init__(frame_name=row.get_frame_name(), frame=partial_frame.get_base_frame())
+        self.__partial_frame = partial_frame
+        self.__window_ref = window_ref
+        self.__row = row
+
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return (f"{self.__partial_frame.to_pure_expression(config)}->first("
+                f"{self.__window_ref.to_pure_expression(config)}, {self.__row.to_pure_expression(config)})")
+
+    def column_sql_expression(
+            self,
+            column: str,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["first_value"]),
+            distinct=False,
+            arguments=[super().column_sql_expression(column, frame_name_to_base_query_map, config)],
+            filter_=None,
+            window=None
+        )
+
+
+class LegendQLApiLastRow(LegendQLApiTdsRow):
+    __partial_frame: LegendQLApiPartialFrame
+    __window_ref: LegendQLApiWindowReference
+    __row: "LegendQLApiTdsRow"
+
+    def __init__(
+            self,
+            partial_frame: LegendQLApiPartialFrame,
+            window_ref: LegendQLApiWindowReference,
+            row: "LegendQLApiTdsRow"
+    ) -> None:
+        super().__init__(frame_name=row.get_frame_name(), frame=partial_frame.get_base_frame())
+        self.__partial_frame = partial_frame
+        self.__window_ref = window_ref
+        self.__row = row
+
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return (f"{self.__partial_frame.to_pure_expression(config)}->last("
+                f"{self.__window_ref.to_pure_expression(config)}, {self.__row.to_pure_expression(config)})")
+
+    def column_sql_expression(
+            self,
+            column: str,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["last_value"]),
+            distinct=False,
+            arguments=[super().column_sql_expression(column, frame_name_to_base_query_map, config)],
+            filter_=None,
+            window=None
+        )
+
+
+class LegendQLApiNthRow(LegendQLApiTdsRow):
+    __partial_frame: LegendQLApiPartialFrame
+    __window_ref: LegendQLApiWindowReference
+    __row: "LegendQLApiTdsRow"
+    __offset: int
+
+    def __init__(
+            self,
+            partial_frame: LegendQLApiPartialFrame,
+            window_ref: LegendQLApiWindowReference,
+            row: "LegendQLApiTdsRow",
+            offset: int
+    ) -> None:
+        super().__init__(frame_name=row.get_frame_name(), frame=partial_frame.get_base_frame())
+        self.__partial_frame = partial_frame
+        self.__window_ref = window_ref
+        self.__row = row
+        self.__offset = offset
+
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return (
+            f"{self.__partial_frame.to_pure_expression(config)}->nth("
+            f"{self.__window_ref.to_pure_expression(config)}, {self.__row.to_pure_expression(config)}, {self.__offset})"
+        )
+
+    def column_sql_expression(
+            self,
+            column: str,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["nth_value"]),
+            distinct=False,
+            arguments=[
+                super().column_sql_expression(column, frame_name_to_base_query_map, config),
+                IntegerLiteral(self.__offset)
+            ],
+            filter_=None,
+            window=None
+        )

pylegend/core/language/shared/__init__.py

@@ -0,0 +1,13 @@
+# 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.

pylegend/core/language/{column_expressions.py → shared/column_expressions.py}

@@ -18,7 +18,7 @@ from pylegend._typing import (
     PyLegendSequence,
     PyLegendDict,
 )
-from pylegend.core.language.expression import (
+from pylegend.core.language.shared.expression import (
     PyLegendExpression,
     PyLegendExpressionBooleanReturn,
     PyLegendExpressionStringReturn,
@@ -32,9 +32,13 @@ from pylegend.core.language.expression import (
 from pylegend.core.sql.metamodel import (
     Expression,
     QuerySpecification,
-    SingleColumn,
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.core.tds.tds_frame import FrameToPureConfig
+from pylegend.core.language.shared.helpers import escape_column_name
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from pylegend.core.language.shared.tds_row import AbstractTdsRow
 
 
 __all__: PyLegendSequence[str] = [
@@ -51,11 +55,11 @@ __all__: PyLegendSequence[str] = [
 
 
 class PyLegendColumnExpression(PyLegendExpression, metaclass=ABCMeta):
-    __frame_name: str
+    __row: "AbstractTdsRow"
     __column: str
 
-    def __init__(self, frame_name: str, column: str) -> None:
-        self.__frame_name = frame_name
+    def __init__(self, row: "AbstractTdsRow", column: str) -> None:
+        self.__row = row
         self.__column = column
 
     def to_sql_expression(
@@ -63,61 +67,58 @@ class PyLegendColumnExpression(PyLegendExpression, metaclass=ABCMeta):
             frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
             config: FrameToSqlConfig
     ) -> Expression:
-        query = frame_name_to_base_query_map[self.__frame_name]
-        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(self.__column))
-        ]
-        if len(filtered) == 0:
-            raise RuntimeError("Cannot find column: " + self.__column)  # pragma: no cover
-        return filtered[0].expression
+        return self.__row.column_sql_expression(self.__column, frame_name_to_base_query_map, config)
+
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return f"{self.__row.to_pure_expression(config)}.{escape_column_name(self.__column)}"
+
+    def get_column(self) -> str:
+        return self.__column
 
 
 class PyLegendBooleanColumnExpression(PyLegendColumnExpression, PyLegendExpressionBooleanReturn):
 
-    def __init__(self, frame_name: str, column: str) -> None:
-        super().__init__(frame_name=frame_name, column=column)
+    def __init__(self, row: "AbstractTdsRow", column: str) -> None:
+        super().__init__(row=row, column=column)
 
 
 class PyLegendStringColumnExpression(PyLegendColumnExpression, PyLegendExpressionStringReturn):
 
-    def __init__(self, frame_name: str, column: str) -> None:
-        super().__init__(frame_name=frame_name, column=column)
+    def __init__(self, row: "AbstractTdsRow", column: str) -> None:
+        super().__init__(row=row, column=column)
 
 
 class PyLegendNumberColumnExpression(PyLegendColumnExpression, PyLegendExpressionNumberReturn):
 
-    def __init__(self, frame_name: str, column: str) -> None:
-        super().__init__(frame_name=frame_name, column=column)
+    def __init__(self, row: "AbstractTdsRow", column: str) -> None:
+        super().__init__(row=row, column=column)
 
 
 class PyLegendIntegerColumnExpression(PyLegendNumberColumnExpression, PyLegendExpressionIntegerReturn):
 
-    def __init__(self, frame_name: str, column: str) -> None:
-        super().__init__(frame_name=frame_name, column=column)
+    def __init__(self, row: "AbstractTdsRow", column: str) -> None:
+        super().__init__(row=row, column=column)
 
 
 class PyLegendFloatColumnExpression(PyLegendNumberColumnExpression, PyLegendExpressionFloatReturn):
 
-    def __init__(self, frame_name: str, column: str) -> None:
-        super().__init__(frame_name=frame_name, column=column)
+    def __init__(self, row: "AbstractTdsRow", column: str) -> None:
+        super().__init__(row=row, column=column)
 
 
 class PyLegendDateColumnExpression(PyLegendColumnExpression, PyLegendExpressionDateReturn):
 
-    def __init__(self, frame_name: str, column: str) -> None:
-        super().__init__(frame_name=frame_name, column=column)
+    def __init__(self, row: "AbstractTdsRow", column: str) -> None:
+        super().__init__(row=row, column=column)
 
 
 class PyLegendDateTimeColumnExpression(PyLegendDateColumnExpression, PyLegendExpressionDateTimeReturn):
 
-    def __init__(self, frame_name: str, column: str) -> None:
-        super().__init__(frame_name=frame_name, column=column)
+    def __init__(self, row: "AbstractTdsRow", column: str) -> None:
+        super().__init__(row=row, column=column)
 
 
 class PyLegendStrictDateColumnExpression(PyLegendDateColumnExpression, PyLegendExpressionStrictDateReturn):
 
-    def __init__(self, frame_name: str, column: str) -> None:
-        super().__init__(frame_name=frame_name, column=column)
+    def __init__(self, row: "AbstractTdsRow", column: str) -> None:
+        super().__init__(row=row, column=column)

pylegend/core/language/{expression.py → shared/expression.py}

@@ -23,6 +23,7 @@ from pylegend.core.sql.metamodel import (
     QuerySpecification,
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.core.tds.tds_frame import FrameToPureConfig
 
 
 __all__: PyLegendSequence[str] = [
@@ -47,6 +48,13 @@ class PyLegendExpression(metaclass=ABCMeta):
     ) -> Expression:
         pass
 
+    @abstractmethod
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        pass
+
+    def is_non_nullable(self) -> bool:
+        return False
+
 
 class PyLegendExpressionBooleanReturn(PyLegendExpression, metaclass=ABCMeta):
     pass

pylegend/core/language/{functions.py → shared/functions.py}

@@ -16,17 +16,22 @@
 from pylegend._typing import (
     PyLegendSequence,
 )
-from pylegend.core.language.primitives.strictdate import PyLegendStrictDate
-from pylegend.core.language.primitives.datetime import PyLegendDateTime
-from pylegend.core.language.operations.date_operation_expressions import (
+from pylegend.core.language.shared.primitives.strictdate import PyLegendStrictDate
+from pylegend.core.language.shared.primitives.datetime import PyLegendDateTime
+from pylegend.core.language.shared.primitives.string import PyLegendString
+from pylegend.core.language.shared.operations.date_operation_expressions import (
     PyLegendTodayExpression,
     PyLegendNowExpression,
 )
+from pylegend.core.language.shared.operations.string_operation_expressions import (
+    PyLegendCurrentUserExpression,
+)
 
 
 __all__: PyLegendSequence[str] = [
     "today",
     "now",
+    "current_user",
 ]
 
 
@@ -36,3 +41,7 @@ def today() -> PyLegendStrictDate:
 
 def now() -> PyLegendDateTime:
     return PyLegendDateTime(PyLegendNowExpression())
+
+
+def current_user() -> PyLegendString:
+    return PyLegendString(PyLegendCurrentUserExpression())

pylegend/core/language/shared/helpers.py

@@ -0,0 +1,75 @@
+# 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
+__all__ = [
+    "generate_pure_functional_call",
+    "generate_pure_lambda",
+    "escape_column_name",
+    "expr_has_matching_start_and_end_parentheses",
+]
+
+
+def generate_pure_functional_call(
+        func: str,
+        params: PyLegendList[str],
+        force_prefix: bool = False,
+        auto_map: bool = False
+) -> str:
+    should_prefix = force_prefix or (len(params) == 0)
+
+    updated_params: PyLegendList[str] = []
+    for param in params:
+        if param.startswith("(") and param.endswith(")"):
+            if expr_has_matching_start_and_end_parentheses(param):
+                updated_params.append(param[1:-1])
+            else:
+                updated_params.append(param)
+        else:
+            updated_params.append(param)
+
+    if auto_map and len(updated_params) == 1:
+        return f"{params[0]}->map(op | {generate_pure_functional_call(func, ['$op'], force_prefix, False)})"
+
+    if auto_map and len(updated_params) == 2:
+        new_params = ['$op'] + [updated_params[1]]
+        return f"{params[0]}->map(op | {generate_pure_functional_call(func, new_params, force_prefix, False)})"
+
+    if should_prefix:
+        return f"{func}({', '.join(updated_params)})"
+    else:
+        return f"{params[0]}->{func}({', '.join(updated_params[1:])})"
+
+
+def generate_pure_lambda(param_name: str, expr: str, wrap_in_braces: bool = True) -> str:
+    lambda_code = param_name + " | " + (expr[1:-1] if expr_has_matching_start_and_end_parentheses(expr) else expr)
+    return "{" + lambda_code + "}" if wrap_in_braces else lambda_code
+
+
+def escape_column_name(name: str) -> str:
+    return (name if name.isidentifier() else "'" + name.replace("'", "\\'") + "'")
+
+
+def expr_has_matching_start_and_end_parentheses(expr: str) -> bool:
+    if expr.startswith("(") and expr.endswith(")"):
+        bracket_indices = [0]
+        for (i, char) in enumerate(expr[1:-1]):
+            if char == "(":
+                bracket_indices.append(i + 1)
+            elif char == ")":
+                if bracket_indices:
+                    bracket_indices.pop()
+        return (len(bracket_indices) == 1) and (bracket_indices[0] == 0)
+    else:
+        return False

pylegend/core/language/{literal_expressions.py → shared/literal_expressions.py}

@@ -19,7 +19,7 @@ from pylegend._typing import (
     PyLegendDict,
     PyLegendUnion,
 )
-from pylegend.core.language.expression import (
+from pylegend.core.language.shared.expression import (
     PyLegendExpression,
     PyLegendExpressionBooleanReturn,
     PyLegendExpressionStringReturn,
@@ -39,6 +39,7 @@ from pylegend.core.sql.metamodel import (
     ColumnType,
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.core.tds.tds_frame import FrameToPureConfig
 
 
 __all__: PyLegendSequence[str] = [
@@ -65,6 +66,12 @@ class PyLegendBooleanLiteralExpression(PyLegendExpressionBooleanReturn):
     ) -> Expression:
         return BooleanLiteral(value=self.__value)
 
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return "true" if self.__value else "false"
+
+    def is_non_nullable(self) -> bool:
+        return True
+
 
 class PyLegendStringLiteralExpression(PyLegendExpressionStringReturn):
     __value: str
@@ -79,6 +86,13 @@ class PyLegendStringLiteralExpression(PyLegendExpressionStringReturn):
     ) -> Expression:
         return StringLiteral(value=self.__value, quoted=False)
 
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        escaped = self.__value.replace("'", "\\'")
+        return f"'{escaped}'"
+
+    def is_non_nullable(self) -> bool:
+        return True
+
 
 class PyLegendIntegerLiteralExpression(PyLegendExpressionIntegerReturn):
     __value: int
@@ -93,6 +107,12 @@ class PyLegendIntegerLiteralExpression(PyLegendExpressionIntegerReturn):
     ) -> Expression:
         return IntegerLiteral(value=self.__value)
 
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return str(self.__value)
+
+    def is_non_nullable(self) -> bool:
+        return True
+
 
 class PyLegendFloatLiteralExpression(PyLegendExpressionFloatReturn):
     __value: float
@@ -107,6 +127,12 @@ class PyLegendFloatLiteralExpression(PyLegendExpressionFloatReturn):
     ) -> Expression:
         return DoubleLiteral(value=self.__value)
 
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return str(self.__value)
+
+    def is_non_nullable(self) -> bool:
+        return True
+
 
 class PyLegendDateTimeLiteralExpression(PyLegendExpressionDateTimeReturn):
     __value: datetime
@@ -124,6 +150,12 @@ class PyLegendDateTimeLiteralExpression(PyLegendExpressionDateTimeReturn):
             type_=ColumnType(name="TIMESTAMP", parameters=[])
         )
 
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return f"%{self.__value.isoformat()}"
+
+    def is_non_nullable(self) -> bool:
+        return True
+
 
 class PyLegendStrictDateLiteralExpression(PyLegendExpressionStrictDateReturn):
     __value: date
@@ -141,6 +173,12 @@ class PyLegendStrictDateLiteralExpression(PyLegendExpressionStrictDateReturn):
             type_=ColumnType(name="DATE", parameters=[])
         )
 
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return f"%{self.__value.isoformat()}"
+
+    def is_non_nullable(self) -> bool:
+        return True
+
 
 def convert_literal_to_literal_expression(
         literal: PyLegendUnion[int, float, bool, str, datetime, date]