pylegend 0.2.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

pylegend/core/language/{operations → shared/operations}/binary_expression.py

@@ -18,14 +18,16 @@ from pylegend._typing import (
     PyLegendDict,
     PyLegendCallable,
 )
-from pylegend.core.language.expression import (
+from pylegend.core.language.shared.expression import (
     PyLegendExpression,
 )
+from pylegend.core.language.shared.helpers import expr_has_matching_start_and_end_parentheses
 from pylegend.core.sql.metamodel import (
     Expression,
     QuerySpecification,
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.core.tds.tds_frame import FrameToPureConfig
 
 
 __all__: PyLegendSequence[str] = [
@@ -40,6 +42,7 @@ class PyLegendBinaryExpression(PyLegendExpression, metaclass=ABCMeta):
         [Expression, Expression, PyLegendDict[str, QuerySpecification], FrameToSqlConfig],
         Expression
     ]
+    __to_pure_func: PyLegendCallable[[str, str, FrameToPureConfig], str]
 
     def __init__(
             self,
@@ -48,11 +51,13 @@ class PyLegendBinaryExpression(PyLegendExpression, metaclass=ABCMeta):
             to_sql_func: PyLegendCallable[
                 [Expression, Expression, PyLegendDict[str, QuerySpecification], FrameToSqlConfig],
                 Expression
-            ]
+            ],
+            to_pure_func: PyLegendCallable[[str, str, FrameToPureConfig], str]
     ) -> None:
         self.__operand1 = operand1
         self.__operand2 = operand2
         self.__to_sql_func = to_sql_func
+        self.__to_pure_func = to_pure_func
 
     def to_sql_expression(
             self,
@@ -67,3 +72,30 @@ class PyLegendBinaryExpression(PyLegendExpression, metaclass=ABCMeta):
             frame_name_to_base_query_map,
             config
         )
+
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        op1_expr = self.__operand1.to_pure_expression(config)
+        op2_expr = self.__operand2.to_pure_expression(config)
+        return self.__to_pure_func(op1_expr, op2_expr, config)
+
+    def to_pure_expression_with_to_one_on_both_operands(self, config: FrameToPureConfig) -> str:
+        op1_expr = self.__operand1.to_pure_expression(config)
+        op1_expr = (
+            op1_expr if self.__operand1.is_non_nullable() else
+            f"toOne({op1_expr[1:-1] if expr_has_matching_start_and_end_parentheses(op1_expr) else op1_expr})"
+        )
+        op2_expr = self.__operand2.to_pure_expression(config)
+        op2_expr = (
+            op2_expr if self.__operand2.is_non_nullable() else
+            f"toOne({op2_expr[1:-1] if expr_has_matching_start_and_end_parentheses(op2_expr) else op2_expr})"
+        )
+        return self.__to_pure_func(op1_expr, op2_expr, config)
+
+    def to_pure_expression_with_to_one_on_second_operand(self, config: FrameToPureConfig) -> str:
+        op1_expr = self.__operand1.to_pure_expression(config)
+        op2_expr = self.__operand2.to_pure_expression(config)
+        op2_expr = (
+            op2_expr if self.__operand2.is_non_nullable() else
+            f"toOne({op2_expr[1:-1] if expr_has_matching_start_and_end_parentheses(op2_expr) else op2_expr})"
+        )
+        return self.__to_pure_func(op1_expr, op2_expr, config)

pylegend/core/language/{operations → shared/operations}/boolean_operation_expressions.py

@@ -16,11 +16,11 @@ from pylegend._typing import (
     PyLegendSequence,
     PyLegendDict,
 )
-from pylegend.core.language.expression import (
+from pylegend.core.language.shared.expression import (
     PyLegendExpressionBooleanReturn,
 )
-from pylegend.core.language.operations.binary_expression import PyLegendBinaryExpression
-from pylegend.core.language.operations.unary_expression import PyLegendUnaryExpression
+from pylegend.core.language.shared.operations.binary_expression import PyLegendBinaryExpression
+from pylegend.core.language.shared.operations.unary_expression import PyLegendUnaryExpression
 from pylegend.core.sql.metamodel import (
     Expression,
     QuerySpecification,
@@ -29,6 +29,7 @@ from pylegend.core.sql.metamodel import (
     NotExpression,
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.core.tds.tds_frame import FrameToPureConfig
 
 
 __all__: PyLegendSequence[str] = [
@@ -49,15 +50,26 @@ class PyLegendBooleanOrExpression(PyLegendBinaryExpression, PyLegendExpressionBo
     ) -> Expression:
         return LogicalBinaryExpression(LogicalBinaryType.OR, expression1, expression2)
 
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return f"({op1_expr} || {op2_expr})"
+
     def __init__(self, operand1: PyLegendExpressionBooleanReturn, operand2: PyLegendExpressionBooleanReturn) -> None:
         PyLegendExpressionBooleanReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendBooleanOrExpression.__to_sql_func
+            PyLegendBooleanOrExpression.__to_sql_func,
+            PyLegendBooleanOrExpression.__to_pure_func
         )
 
+    def is_non_nullable(self) -> bool:
+        return True
+
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return PyLegendBinaryExpression.to_pure_expression_with_to_one_on_both_operands(self, config)
+
 
 class PyLegendBooleanAndExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
 
@@ -70,15 +82,26 @@ class PyLegendBooleanAndExpression(PyLegendBinaryExpression, PyLegendExpressionB
     ) -> Expression:
         return LogicalBinaryExpression(LogicalBinaryType.AND, expression1, expression2)
 
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return f"({op1_expr} && {op2_expr})"
+
     def __init__(self, operand1: PyLegendExpressionBooleanReturn, operand2: PyLegendExpressionBooleanReturn) -> None:
         PyLegendExpressionBooleanReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendBooleanAndExpression.__to_sql_func
+            PyLegendBooleanAndExpression.__to_sql_func,
+            PyLegendBooleanAndExpression.__to_pure_func
         )
 
+    def is_non_nullable(self) -> bool:
+        return True
+
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return PyLegendBinaryExpression.to_pure_expression_with_to_one_on_both_operands(self, config)
+
 
 class PyLegendBooleanNotExpression(PyLegendUnaryExpression, PyLegendExpressionBooleanReturn):
 
@@ -90,10 +113,15 @@ class PyLegendBooleanNotExpression(PyLegendUnaryExpression, PyLegendExpressionBo
     ) -> Expression:
         return NotExpression(expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return f"{op_expr}->map(op | !$op)"
+
     def __init__(self, operand: PyLegendExpressionBooleanReturn) -> None:
         PyLegendExpressionBooleanReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendBooleanNotExpression.__to_sql_func
+            PyLegendBooleanNotExpression.__to_sql_func,
+            PyLegendBooleanNotExpression.__to_pure_func
         )

pylegend/core/language/{operations → shared/operations}/collection_operation_expressions.py

@@ -16,7 +16,7 @@ from pylegend._typing import (
     PyLegendSequence,
     PyLegendDict,
 )
-from pylegend.core.language.expression import (
+from pylegend.core.language.shared.expression import (
     PyLegendExpression,
     PyLegendExpressionIntegerReturn,
     PyLegendExpressionFloatReturn,
@@ -25,9 +25,11 @@ from pylegend.core.language.expression import (
     PyLegendExpressionStrictDateReturn,
     PyLegendExpressionDateReturn,
 )
-from pylegend.core.language.operations.unary_expression import PyLegendUnaryExpression
-from pylegend.core.language.operations.binary_expression import PyLegendBinaryExpression
+from pylegend.core.language.shared.operations.unary_expression import PyLegendUnaryExpression
+from pylegend.core.language.shared.helpers import generate_pure_functional_call
+from pylegend.core.language.shared.operations.binary_expression import PyLegendBinaryExpression
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.core.tds.tds_frame import FrameToPureConfig
 from pylegend.core.sql.metamodel import (
     Expression,
     QuerySpecification,
@@ -84,12 +86,17 @@ class PyLegendCountExpression(PyLegendUnaryExpression, PyLegendExpressionInteger
     ) -> Expression:
         return CountExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("count", [op_expr])
+
     def __init__(self, operand: PyLegendExpression) -> None:
         PyLegendExpressionIntegerReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendCountExpression.__to_sql_func
+            PyLegendCountExpression.__to_sql_func,
+            PyLegendCountExpression.__to_pure_func
         )
 
 
@@ -103,12 +110,20 @@ class PyLegendDistinctCountExpression(PyLegendUnaryExpression, PyLegendExpressio
     ) -> Expression:
         return DistinctCountExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call(
+            "count",
+            [generate_pure_functional_call("distinct", [op_expr])]
+        )
+
     def __init__(self, operand: PyLegendExpression) -> None:
         PyLegendExpressionIntegerReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendDistinctCountExpression.__to_sql_func
+            PyLegendDistinctCountExpression.__to_sql_func,
+            PyLegendDistinctCountExpression.__to_pure_func
         )
 
 
@@ -122,12 +137,17 @@ class PyLegendAverageExpression(PyLegendUnaryExpression, PyLegendExpressionFloat
     ) -> Expression:
         return AverageExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("average", [op_expr])
+
     def __init__(self, operand: PyLegendExpressionNumberReturn) -> None:
         PyLegendExpressionFloatReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendAverageExpression.__to_sql_func
+            PyLegendAverageExpression.__to_sql_func,
+            PyLegendAverageExpression.__to_pure_func
         )
 
 
@@ -141,12 +161,17 @@ class PyLegendIntegerMaxExpression(PyLegendUnaryExpression, PyLegendExpressionIn
     ) -> Expression:
         return MaxExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("max", [op_expr])
+
     def __init__(self, operand: PyLegendExpressionIntegerReturn) -> None:
         PyLegendExpressionIntegerReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendIntegerMaxExpression.__to_sql_func
+            PyLegendIntegerMaxExpression.__to_sql_func,
+            PyLegendIntegerMaxExpression.__to_pure_func
         )
 
 
@@ -160,12 +185,17 @@ class PyLegendIntegerMinExpression(PyLegendUnaryExpression, PyLegendExpressionIn
     ) -> Expression:
         return MinExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("min", [op_expr])
+
     def __init__(self, operand: PyLegendExpressionIntegerReturn) -> None:
         PyLegendExpressionIntegerReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendIntegerMinExpression.__to_sql_func
+            PyLegendIntegerMinExpression.__to_sql_func,
+            PyLegendIntegerMinExpression.__to_pure_func
         )
 
 
@@ -179,12 +209,17 @@ class PyLegendIntegerSumExpression(PyLegendUnaryExpression, PyLegendExpressionIn
     ) -> Expression:
         return SumExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("sum", [op_expr])
+
     def __init__(self, operand: PyLegendExpressionIntegerReturn) -> None:
         PyLegendExpressionIntegerReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendIntegerSumExpression.__to_sql_func
+            PyLegendIntegerSumExpression.__to_sql_func,
+            PyLegendIntegerSumExpression.__to_pure_func
         )
 
 
@@ -198,12 +233,17 @@ class PyLegendFloatMaxExpression(PyLegendUnaryExpression, PyLegendExpressionFloa
     ) -> Expression:
         return MaxExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("max", [op_expr])
+
     def __init__(self, operand: PyLegendExpressionFloatReturn) -> None:
         PyLegendExpressionFloatReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendFloatMaxExpression.__to_sql_func
+            PyLegendFloatMaxExpression.__to_sql_func,
+            PyLegendFloatMaxExpression.__to_pure_func
         )
 
 
@@ -217,12 +257,17 @@ class PyLegendFloatMinExpression(PyLegendUnaryExpression, PyLegendExpressionFloa
     ) -> Expression:
         return MinExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("min", [op_expr])
+
     def __init__(self, operand: PyLegendExpressionFloatReturn) -> None:
         PyLegendExpressionFloatReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendFloatMinExpression.__to_sql_func
+            PyLegendFloatMinExpression.__to_sql_func,
+            PyLegendFloatMinExpression.__to_pure_func
         )
 
 
@@ -236,12 +281,17 @@ class PyLegendFloatSumExpression(PyLegendUnaryExpression, PyLegendExpressionFloa
     ) -> Expression:
         return SumExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("sum", [op_expr])
+
     def __init__(self, operand: PyLegendExpressionFloatReturn) -> None:
         PyLegendExpressionFloatReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendFloatSumExpression.__to_sql_func
+            PyLegendFloatSumExpression.__to_sql_func,
+            PyLegendFloatSumExpression.__to_pure_func
         )
 
 
@@ -255,12 +305,17 @@ class PyLegendNumberMaxExpression(PyLegendUnaryExpression, PyLegendExpressionNum
     ) -> Expression:
         return MaxExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("max", [op_expr])
+
     def __init__(self, operand: PyLegendExpressionNumberReturn) -> None:
         PyLegendExpressionNumberReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendNumberMaxExpression.__to_sql_func
+            PyLegendNumberMaxExpression.__to_sql_func,
+            PyLegendNumberMaxExpression.__to_pure_func
         )
 
 
@@ -274,12 +329,17 @@ class PyLegendNumberMinExpression(PyLegendUnaryExpression, PyLegendExpressionNum
     ) -> Expression:
         return MinExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("min", [op_expr])
+
     def __init__(self, operand: PyLegendExpressionNumberReturn) -> None:
         PyLegendExpressionNumberReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendNumberMinExpression.__to_sql_func
+            PyLegendNumberMinExpression.__to_sql_func,
+            PyLegendNumberMinExpression.__to_pure_func
         )
 
 
@@ -293,12 +353,17 @@ class PyLegendNumberSumExpression(PyLegendUnaryExpression, PyLegendExpressionNum
     ) -> Expression:
         return SumExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("sum", [op_expr])
+
     def __init__(self, operand: PyLegendExpressionNumberReturn) -> None:
         PyLegendExpressionNumberReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendNumberSumExpression.__to_sql_func
+            PyLegendNumberSumExpression.__to_sql_func,
+            PyLegendNumberSumExpression.__to_pure_func
         )
 
 
@@ -312,12 +377,17 @@ class PyLegendStdDevSampleExpression(PyLegendUnaryExpression, PyLegendExpression
     ) -> Expression:
         return StdDevSampleExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("stdDevSample", [op_expr])
+
     def __init__(self, operand: PyLegendExpressionNumberReturn) -> None:
         PyLegendExpressionNumberReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStdDevSampleExpression.__to_sql_func
+            PyLegendStdDevSampleExpression.__to_sql_func,
+            PyLegendStdDevSampleExpression.__to_pure_func
         )
 
 
@@ -331,12 +401,17 @@ class PyLegendStdDevPopulationExpression(PyLegendUnaryExpression, PyLegendExpres
     ) -> Expression:
         return StdDevPopulationExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("stdDevPopulation", [op_expr])
+
     def __init__(self, operand: PyLegendExpressionNumberReturn) -> None:
         PyLegendExpressionNumberReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStdDevPopulationExpression.__to_sql_func
+            PyLegendStdDevPopulationExpression.__to_sql_func,
+            PyLegendStdDevPopulationExpression.__to_pure_func
         )
 
 
@@ -350,12 +425,17 @@ class PyLegendVarianceSampleExpression(PyLegendUnaryExpression, PyLegendExpressi
     ) -> Expression:
         return VarianceSampleExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("varianceSample", [op_expr])
+
     def __init__(self, operand: PyLegendExpressionNumberReturn) -> None:
         PyLegendExpressionNumberReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendVarianceSampleExpression.__to_sql_func
+            PyLegendVarianceSampleExpression.__to_sql_func,
+            PyLegendVarianceSampleExpression.__to_pure_func
         )
 
 
@@ -369,12 +449,17 @@ class PyLegendVariancePopulationExpression(PyLegendUnaryExpression, PyLegendExpr
     ) -> Expression:
         return VariancePopulationExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("variancePopulation", [op_expr])
+
     def __init__(self, operand: PyLegendExpressionNumberReturn) -> None:
         PyLegendExpressionNumberReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendVariancePopulationExpression.__to_sql_func
+            PyLegendVariancePopulationExpression.__to_sql_func,
+            PyLegendVariancePopulationExpression.__to_pure_func
         )
 
 
@@ -388,12 +473,17 @@ class PyLegendStringMaxExpression(PyLegendUnaryExpression, PyLegendExpressionStr
     ) -> Expression:
         return MaxExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("max", [op_expr])
+
     def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionStringReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStringMaxExpression.__to_sql_func
+            PyLegendStringMaxExpression.__to_sql_func,
+            PyLegendStringMaxExpression.__to_pure_func
         )
 
 
@@ -407,12 +497,17 @@ class PyLegendStringMinExpression(PyLegendUnaryExpression, PyLegendExpressionStr
     ) -> Expression:
         return MinExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("min", [op_expr])
+
     def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionStringReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStringMinExpression.__to_sql_func
+            PyLegendStringMinExpression.__to_sql_func,
+            PyLegendStringMinExpression.__to_pure_func
         )
 
 
@@ -427,13 +522,18 @@ class PyLegendJoinStringsExpression(PyLegendBinaryExpression, PyLegendExpression
     ) -> Expression:
         return JoinStringsExpression(value=expression1, other=expression2)
 
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("joinStrings", [op1_expr, op2_expr])
+
     def __init__(self, operand1: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionStringReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendJoinStringsExpression.__to_sql_func
+            PyLegendJoinStringsExpression.__to_sql_func,
+            PyLegendJoinStringsExpression.__to_pure_func
         )
 
 
@@ -447,12 +547,17 @@ class PyLegendStrictDateMaxExpression(PyLegendUnaryExpression, PyLegendExpressio
     ) -> Expression:
         return MaxExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("max", [op_expr])
+
     def __init__(self, operand: PyLegendExpressionStrictDateReturn) -> None:
         PyLegendExpressionStrictDateReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStrictDateMaxExpression.__to_sql_func
+            PyLegendStrictDateMaxExpression.__to_sql_func,
+            PyLegendStrictDateMaxExpression.__to_pure_func
         )
 
 
@@ -466,12 +571,17 @@ class PyLegendStrictDateMinExpression(PyLegendUnaryExpression, PyLegendExpressio
     ) -> Expression:
         return MinExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("min", [op_expr])
+
     def __init__(self, operand: PyLegendExpressionStrictDateReturn) -> None:
         PyLegendExpressionStrictDateReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStrictDateMinExpression.__to_sql_func
+            PyLegendStrictDateMinExpression.__to_sql_func,
+            PyLegendStrictDateMinExpression.__to_pure_func
         )
 
 
@@ -485,12 +595,17 @@ class PyLegendDateMaxExpression(PyLegendUnaryExpression, PyLegendExpressionDateR
     ) -> Expression:
         return MaxExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("max", [op_expr])
+
     def __init__(self, operand: PyLegendExpressionDateReturn) -> None:
         PyLegendExpressionDateReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendDateMaxExpression.__to_sql_func
+            PyLegendDateMaxExpression.__to_sql_func,
+            PyLegendDateMaxExpression.__to_pure_func
         )
 
 
@@ -504,10 +619,15 @@ class PyLegendDateMinExpression(PyLegendUnaryExpression, PyLegendExpressionDateR
     ) -> Expression:
         return MinExpression(value=expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("min", [op_expr])
+
     def __init__(self, operand: PyLegendExpressionDateReturn) -> None:
         PyLegendExpressionDateReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendDateMinExpression.__to_sql_func
+            PyLegendDateMinExpression.__to_sql_func,
+            PyLegendDateMinExpression.__to_pure_func
         )