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

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

@@ -16,11 +16,12 @@ from pylegend._typing import (
     PyLegendSequence,
     PyLegendDict,
 )
-from pylegend.core.language.expression import (
+from pylegend.core.language.shared.expression import (
     PyLegendExpressionFloatReturn,
 )
-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.language.shared.helpers import generate_pure_functional_call
 from pylegend.core.sql.metamodel import (
     Expression,
     QuerySpecification,
@@ -32,6 +33,7 @@ from pylegend.core.sql.metamodel_extension import (
     AbsoluteExpression,
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.core.tds.tds_frame import FrameToPureConfig
 
 
 __all__: PyLegendSequence[str] = [
@@ -54,15 +56,26 @@ class PyLegendFloatAddExpression(PyLegendBinaryExpression, PyLegendExpressionFlo
     ) -> Expression:
         return ArithmeticExpression(ArithmeticType.ADD, 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: PyLegendExpressionFloatReturn, operand2: PyLegendExpressionFloatReturn) -> None:
         PyLegendExpressionFloatReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendFloatAddExpression.__to_sql_func
+            PyLegendFloatAddExpression.__to_sql_func,
+            PyLegendFloatAddExpression.__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 PyLegendFloatSubtractExpression(PyLegendBinaryExpression, PyLegendExpressionFloatReturn):
 
@@ -75,15 +88,26 @@ class PyLegendFloatSubtractExpression(PyLegendBinaryExpression, PyLegendExpressi
     ) -> Expression:
         return ArithmeticExpression(ArithmeticType.SUBTRACT, 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: PyLegendExpressionFloatReturn, operand2: PyLegendExpressionFloatReturn) -> None:
         PyLegendExpressionFloatReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendFloatSubtractExpression.__to_sql_func
+            PyLegendFloatSubtractExpression.__to_sql_func,
+            PyLegendFloatSubtractExpression.__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 PyLegendFloatMultiplyExpression(PyLegendBinaryExpression, PyLegendExpressionFloatReturn):
 
@@ -96,15 +120,26 @@ class PyLegendFloatMultiplyExpression(PyLegendBinaryExpression, PyLegendExpressi
     ) -> Expression:
         return ArithmeticExpression(ArithmeticType.MULTIPLY, 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: PyLegendExpressionFloatReturn, operand2: PyLegendExpressionFloatReturn) -> None:
         PyLegendExpressionFloatReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendFloatMultiplyExpression.__to_sql_func
+            PyLegendFloatMultiplyExpression.__to_sql_func,
+            PyLegendFloatMultiplyExpression.__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 PyLegendFloatAbsoluteExpression(PyLegendUnaryExpression, PyLegendExpressionFloatReturn):
 
@@ -116,12 +151,17 @@ class PyLegendFloatAbsoluteExpression(PyLegendUnaryExpression, PyLegendExpressio
     ) -> Expression:
         return AbsoluteExpression(expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("abs", [op_expr], auto_map=True)
+
     def __init__(self, operand: PyLegendExpressionFloatReturn) -> None:
         PyLegendExpressionFloatReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendFloatAbsoluteExpression.__to_sql_func
+            PyLegendFloatAbsoluteExpression.__to_sql_func,
+            PyLegendFloatAbsoluteExpression.__to_pure_func
         )
 
 
@@ -135,10 +175,15 @@ class PyLegendFloatNegativeExpression(PyLegendUnaryExpression, PyLegendExpressio
     ) -> Expression:
         return NegativeExpression(expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("minus", [op_expr], auto_map=True)
+
     def __init__(self, operand: PyLegendExpressionFloatReturn) -> None:
         PyLegendExpressionFloatReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendFloatNegativeExpression.__to_sql_func
+            PyLegendFloatNegativeExpression.__to_sql_func,
+            PyLegendFloatNegativeExpression.__to_pure_func
         )

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

@@ -16,11 +16,12 @@ from pylegend._typing import (
     PyLegendSequence,
     PyLegendDict,
 )
-from pylegend.core.language.expression import (
+from pylegend.core.language.shared.expression import (
     PyLegendExpressionIntegerReturn,
 )
-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.language.shared.helpers import generate_pure_functional_call
 from pylegend.core.sql.metamodel import (
     Expression,
     QuerySpecification,
@@ -32,6 +33,7 @@ from pylegend.core.sql.metamodel_extension import (
     AbsoluteExpression,
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.core.tds.tds_frame import FrameToPureConfig
 
 
 __all__: PyLegendSequence[str] = [
@@ -55,15 +57,26 @@ class PyLegendIntegerAddExpression(PyLegendBinaryExpression, PyLegendExpressionI
     ) -> Expression:
         return ArithmeticExpression(ArithmeticType.ADD, 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: PyLegendExpressionIntegerReturn, operand2: PyLegendExpressionIntegerReturn) -> None:
         PyLegendExpressionIntegerReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendIntegerAddExpression.__to_sql_func
+            PyLegendIntegerAddExpression.__to_sql_func,
+            PyLegendIntegerAddExpression.__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 PyLegendIntegerSubtractExpression(PyLegendBinaryExpression, PyLegendExpressionIntegerReturn):
 
@@ -76,15 +89,26 @@ class PyLegendIntegerSubtractExpression(PyLegendBinaryExpression, PyLegendExpres
     ) -> Expression:
         return ArithmeticExpression(ArithmeticType.SUBTRACT, 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: PyLegendExpressionIntegerReturn, operand2: PyLegendExpressionIntegerReturn) -> None:
         PyLegendExpressionIntegerReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendIntegerSubtractExpression.__to_sql_func
+            PyLegendIntegerSubtractExpression.__to_sql_func,
+            PyLegendIntegerSubtractExpression.__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 PyLegendIntegerMultiplyExpression(PyLegendBinaryExpression, PyLegendExpressionIntegerReturn):
 
@@ -97,15 +121,26 @@ class PyLegendIntegerMultiplyExpression(PyLegendBinaryExpression, PyLegendExpres
     ) -> Expression:
         return ArithmeticExpression(ArithmeticType.MULTIPLY, 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: PyLegendExpressionIntegerReturn, operand2: PyLegendExpressionIntegerReturn) -> None:
         PyLegendExpressionIntegerReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendIntegerMultiplyExpression.__to_sql_func
+            PyLegendIntegerMultiplyExpression.__to_sql_func,
+            PyLegendIntegerMultiplyExpression.__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 PyLegendIntegerModuloExpression(PyLegendBinaryExpression, PyLegendExpressionIntegerReturn):
 
@@ -118,15 +153,23 @@ class PyLegendIntegerModuloExpression(PyLegendBinaryExpression, PyLegendExpressi
     ) -> Expression:
         return ArithmeticExpression(ArithmeticType.MODULUS, expression1, expression2)
 
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("mod", [op1_expr, op2_expr], auto_map=True)
+
     def __init__(self, operand1: PyLegendExpressionIntegerReturn, operand2: PyLegendExpressionIntegerReturn) -> None:
         PyLegendExpressionIntegerReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendIntegerModuloExpression.__to_sql_func
+            PyLegendIntegerModuloExpression.__to_sql_func,
+            PyLegendIntegerModuloExpression.__to_pure_func
         )
 
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return PyLegendBinaryExpression.to_pure_expression_with_to_one_on_second_operand(self, config)
+
 
 class PyLegendIntegerAbsoluteExpression(PyLegendUnaryExpression, PyLegendExpressionIntegerReturn):
 
@@ -138,12 +181,17 @@ class PyLegendIntegerAbsoluteExpression(PyLegendUnaryExpression, PyLegendExpress
     ) -> Expression:
         return AbsoluteExpression(expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("abs", [op_expr], auto_map=True)
+
     def __init__(self, operand: PyLegendExpressionIntegerReturn) -> None:
         PyLegendExpressionIntegerReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendIntegerAbsoluteExpression.__to_sql_func
+            PyLegendIntegerAbsoluteExpression.__to_sql_func,
+            PyLegendIntegerAbsoluteExpression.__to_pure_func
         )
 
 
@@ -157,10 +205,15 @@ class PyLegendIntegerNegativeExpression(PyLegendUnaryExpression, PyLegendExpress
     ) -> Expression:
         return NegativeExpression(expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("minus", [op_expr], auto_map=True)
+
     def __init__(self, operand: PyLegendExpressionIntegerReturn) -> None:
         PyLegendExpressionIntegerReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendIntegerNegativeExpression.__to_sql_func
+            PyLegendIntegerNegativeExpression.__to_sql_func,
+            PyLegendIntegerNegativeExpression.__to_pure_func
         )

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

@@ -18,7 +18,7 @@ from pylegend._typing import (
     PyLegendDict,
     PyLegendCallable,
 )
-from pylegend.core.language.expression import (
+from pylegend.core.language.shared.expression import (
     PyLegendExpression,
 )
 from pylegend.core.sql.metamodel import (
@@ -26,6 +26,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] = [
@@ -38,15 +39,18 @@ class PyLegendNullaryExpression(PyLegendExpression, metaclass=ABCMeta):
         [PyLegendDict[str, QuerySpecification], FrameToSqlConfig],
         Expression
     ]
+    __to_pure_func: PyLegendCallable[[FrameToPureConfig], str]
 
     def __init__(
             self,
             to_sql_func: PyLegendCallable[
                 [PyLegendDict[str, QuerySpecification], FrameToSqlConfig],
                 Expression
-            ]
+            ],
+            to_pure_func: PyLegendCallable[[FrameToPureConfig], str]
     ) -> None:
         self.__to_sql_func = to_sql_func
+        self.__to_pure_func = to_pure_func
 
     def to_sql_expression(
             self,
@@ -57,3 +61,6 @@ class PyLegendNullaryExpression(PyLegendExpression, metaclass=ABCMeta):
             frame_name_to_base_query_map,
             config
         )
+
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return self.__to_pure_func(config)