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

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

@@ -16,14 +16,15 @@ from pylegend._typing import (
     PyLegendSequence,
     PyLegendDict,
 )
-from pylegend.core.language.expression import (
+from pylegend.core.language.shared.expression import (
     PyLegendExpressionStringReturn,
     PyLegendExpressionIntegerReturn,
     PyLegendExpressionFloatReturn,
     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.language.shared.helpers import generate_pure_functional_call
 from pylegend.core.sql.metamodel import (
     Expression,
     QuerySpecification,
@@ -31,6 +32,7 @@ from pylegend.core.sql.metamodel import (
     Cast,
     ComparisonOperator,
     ComparisonExpression,
+    StringLiteral,
 )
 from pylegend.core.sql.metamodel_extension import (
     StringLengthExpression,
@@ -43,11 +45,14 @@ from pylegend.core.sql.metamodel_extension import (
     StringConcatExpression,
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.core.tds.tds_frame import FrameToPureConfig
 
 
 __all__: PyLegendSequence[str] = [
     "PyLegendStringLengthExpression",
-    "PyLegendStringLikeExpression",
+    "PyLegendStringStartsWithExpression",
+    "PyLegendStringEndsWithExpression",
+    "PyLegendStringContainsExpression",
     "PyLegendStringUpperExpression",
     "PyLegendStringLowerExpression",
     "PyLegendStringLTrimExpression",
@@ -74,16 +79,77 @@ class PyLegendStringLengthExpression(PyLegendUnaryExpression, PyLegendExpression
     ) -> Expression:
         return StringLengthExpression(expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("length", [op_expr], auto_map=True)
+
     def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionIntegerReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStringLengthExpression.__to_sql_func
+            PyLegendStringLengthExpression.__to_sql_func,
+            PyLegendStringLengthExpression.__to_pure_func
+        )
+
+
+class PyLegendStringStartsWithExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        assert isinstance(expression2, StringLiteral)
+        escaped = _escape_like_param(expression2.value)
+        return StringLikeExpression(expression1, StringLiteral(value=escaped + "%", quoted=False))
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("startsWith", [op1_expr, op2_expr])
+
+    def __init__(self, operand1: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendStringStartsWithExpression.__to_sql_func,
+            PyLegendStringStartsWithExpression.__to_pure_func
+        )
+
+
+class PyLegendStringEndsWithExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        assert isinstance(expression2, StringLiteral)
+        escaped = _escape_like_param(expression2.value)
+        return StringLikeExpression(expression1, StringLiteral(value="%" + escaped, quoted=False))
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("endsWith", [op1_expr, op2_expr])
+
+    def __init__(self, operand1: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendStringEndsWithExpression.__to_sql_func,
+            PyLegendStringEndsWithExpression.__to_pure_func
         )
 
 
-class PyLegendStringLikeExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
+class PyLegendStringContainsExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
 
     @staticmethod
     def __to_sql_func(
@@ -92,7 +158,13 @@ class PyLegendStringLikeExpression(PyLegendBinaryExpression, PyLegendExpressionB
             frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
             config: FrameToSqlConfig
     ) -> Expression:
-        return StringLikeExpression(expression1, expression2)
+        assert isinstance(expression2, StringLiteral)
+        escaped = _escape_like_param(expression2.value)
+        return StringLikeExpression(expression1, StringLiteral(value="%" + escaped + "%", quoted=False))
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("contains", [op1_expr, op2_expr])
 
     def __init__(self, operand1: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionBooleanReturn.__init__(self)
@@ -100,7 +172,8 @@ class PyLegendStringLikeExpression(PyLegendBinaryExpression, PyLegendExpressionB
             self,
             operand1,
             operand2,
-            PyLegendStringLikeExpression.__to_sql_func
+            PyLegendStringContainsExpression.__to_sql_func,
+            PyLegendStringContainsExpression.__to_pure_func
         )
 
 
@@ -114,12 +187,17 @@ class PyLegendStringUpperExpression(PyLegendUnaryExpression, PyLegendExpressionS
     ) -> Expression:
         return StringUpperExpression(expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("toUpper", [op_expr], auto_map=True)
+
     def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionStringReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStringUpperExpression.__to_sql_func
+            PyLegendStringUpperExpression.__to_sql_func,
+            PyLegendStringUpperExpression.__to_pure_func
         )
 
 
@@ -133,12 +211,17 @@ class PyLegendStringLowerExpression(PyLegendUnaryExpression, PyLegendExpressionS
     ) -> Expression:
         return StringLowerExpression(expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("toLower", [op_expr], auto_map=True)
+
     def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionStringReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStringLowerExpression.__to_sql_func
+            PyLegendStringLowerExpression.__to_sql_func,
+            PyLegendStringLowerExpression.__to_pure_func
         )
 
 
@@ -152,12 +235,17 @@ class PyLegendStringLTrimExpression(PyLegendUnaryExpression, PyLegendExpressionS
     ) -> Expression:
         return StringTrimExpression(expression, trim_type=TrimType.Left)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("ltrim", [op_expr], auto_map=True)
+
     def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionStringReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStringLTrimExpression.__to_sql_func
+            PyLegendStringLTrimExpression.__to_sql_func,
+            PyLegendStringLTrimExpression.__to_pure_func
         )
 
 
@@ -171,12 +259,17 @@ class PyLegendStringRTrimExpression(PyLegendUnaryExpression, PyLegendExpressionS
     ) -> Expression:
         return StringTrimExpression(expression, trim_type=TrimType.Right)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("rtrim", [op_expr], auto_map=True)
+
     def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionStringReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStringRTrimExpression.__to_sql_func
+            PyLegendStringRTrimExpression.__to_sql_func,
+            PyLegendStringRTrimExpression.__to_pure_func
         )
 
 
@@ -190,12 +283,17 @@ class PyLegendStringBTrimExpression(PyLegendUnaryExpression, PyLegendExpressionS
     ) -> Expression:
         return StringTrimExpression(expression, trim_type=TrimType.Both)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("trim", [op_expr], auto_map=True)
+
     def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionStringReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStringBTrimExpression.__to_sql_func
+            PyLegendStringBTrimExpression.__to_sql_func,
+            PyLegendStringBTrimExpression.__to_pure_func
         )
 
 
@@ -210,15 +308,23 @@ class PyLegendStringPosExpression(PyLegendBinaryExpression, PyLegendExpressionIn
     ) -> Expression:
         return StringPosExpression(expression1, expression2)
 
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("indexOf", [op1_expr, op2_expr], auto_map=True)
+
     def __init__(self, operand1: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionIntegerReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendStringPosExpression.__to_sql_func
+            PyLegendStringPosExpression.__to_sql_func,
+            PyLegendStringPosExpression.__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 PyLegendStringParseIntExpression(PyLegendUnaryExpression, PyLegendExpressionIntegerReturn):
 
@@ -230,12 +336,17 @@ class PyLegendStringParseIntExpression(PyLegendUnaryExpression, PyLegendExpressi
     ) -> Expression:
         return Cast(expression, ColumnType(name="INTEGER", parameters=[]))
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("parseInteger", [op_expr], auto_map=True)
+
     def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionIntegerReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStringParseIntExpression.__to_sql_func
+            PyLegendStringParseIntExpression.__to_sql_func,
+            PyLegendStringParseIntExpression.__to_pure_func
         )
 
 
@@ -249,12 +360,17 @@ class PyLegendStringParseFloatExpression(PyLegendUnaryExpression, PyLegendExpres
     ) -> Expression:
         return Cast(expression, ColumnType(name="DOUBLE PRECISION", parameters=[]))
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("parseFloat", [op_expr], auto_map=True)
+
     def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionFloatReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStringParseFloatExpression.__to_sql_func
+            PyLegendStringParseFloatExpression.__to_sql_func,
+            PyLegendStringParseFloatExpression.__to_pure_func
         )
 
 
@@ -269,15 +385,23 @@ class PyLegendStringConcatExpression(PyLegendBinaryExpression, PyLegendExpressio
     ) -> Expression:
         return StringConcatExpression(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: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionStringReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendStringConcatExpression.__to_sql_func
+            PyLegendStringConcatExpression.__to_sql_func,
+            PyLegendStringConcatExpression.__to_pure_func
         )
 
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return PyLegendBinaryExpression.to_pure_expression_with_to_one_on_both_operands(self, config)
+
 
 class PyLegendStringLessThanExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
 
@@ -290,13 +414,18 @@ class PyLegendStringLessThanExpression(PyLegendBinaryExpression, PyLegendExpress
     ) -> Expression:
         return ComparisonExpression(expression1, expression2, ComparisonOperator.LESS_THAN)
 
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return f"({op1_expr} < {op2_expr})"
+
     def __init__(self, operand1: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionBooleanReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendStringLessThanExpression.__to_sql_func
+            PyLegendStringLessThanExpression.__to_sql_func,
+            PyLegendStringLessThanExpression.__to_pure_func
         )
 
 
@@ -311,13 +440,18 @@ class PyLegendStringLessThanEqualExpression(PyLegendBinaryExpression, PyLegendEx
     ) -> Expression:
         return ComparisonExpression(expression1, expression2, ComparisonOperator.LESS_THAN_OR_EQUAL)
 
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return f"({op1_expr} <= {op2_expr})"
+
     def __init__(self, operand1: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionBooleanReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendStringLessThanEqualExpression.__to_sql_func
+            PyLegendStringLessThanEqualExpression.__to_sql_func,
+            PyLegendStringLessThanEqualExpression.__to_pure_func
         )
 
 
@@ -332,13 +466,18 @@ class PyLegendStringGreaterThanExpression(PyLegendBinaryExpression, PyLegendExpr
     ) -> Expression:
         return ComparisonExpression(expression1, expression2, ComparisonOperator.GREATER_THAN)
 
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return f"({op1_expr} > {op2_expr})"
+
     def __init__(self, operand1: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionBooleanReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendStringGreaterThanExpression.__to_sql_func
+            PyLegendStringGreaterThanExpression.__to_sql_func,
+            PyLegendStringGreaterThanExpression.__to_pure_func
         )
 
 
@@ -353,11 +492,20 @@ class PyLegendStringGreaterThanEqualExpression(PyLegendBinaryExpression, PyLegen
     ) -> Expression:
         return ComparisonExpression(expression1, expression2, ComparisonOperator.GREATER_THAN_OR_EQUAL)
 
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return f"({op1_expr} >= {op2_expr})"
+
     def __init__(self, operand1: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionBooleanReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendStringGreaterThanEqualExpression.__to_sql_func
+            PyLegendStringGreaterThanEqualExpression.__to_sql_func,
+            PyLegendStringGreaterThanEqualExpression.__to_pure_func
         )
+
+
+def _escape_like_param(param: str) -> str:
+    return param.replace("_", "\\_").replace("%", "\\%")

pylegend/core/language/{operations → shared/operations}/unary_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] = [
@@ -39,6 +40,7 @@ class PyLegendUnaryExpression(PyLegendExpression, metaclass=ABCMeta):
         [Expression, PyLegendDict[str, QuerySpecification], FrameToSqlConfig],
         Expression
     ]
+    __to_pure_func: PyLegendCallable[[str, FrameToPureConfig], str]
 
     def __init__(
             self,
@@ -46,10 +48,12 @@ class PyLegendUnaryExpression(PyLegendExpression, metaclass=ABCMeta):
             to_sql_func: PyLegendCallable[
                 [Expression, PyLegendDict[str, QuerySpecification], FrameToSqlConfig],
                 Expression
-            ]
+            ],
+            to_pure_func: PyLegendCallable[[str, FrameToPureConfig], str]
     ) -> None:
         self.__operand = operand
         self.__to_sql_func = to_sql_func
+        self.__to_pure_func = to_pure_func
 
     def to_sql_expression(
             self,
@@ -62,3 +66,7 @@ class PyLegendUnaryExpression(PyLegendExpression, metaclass=ABCMeta):
             frame_name_to_base_query_map,
             config
         )
+
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        op_expr = self.__operand.to_pure_expression(config)
+        return self.__to_pure_func(op_expr, config)

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

@@ -18,7 +18,7 @@ from pylegend._typing import (
     PyLegendSequence,
     PyLegendUnion,
 )
-from pylegend.core.language.primitives.primitive import PyLegendPrimitiveOrPythonPrimitive
+from pylegend.core.language.shared.primitives.primitive import PyLegendPrimitiveOrPythonPrimitive
 from pylegend.core.language import (
     PyLegendInteger,
     PyLegendFloat,
@@ -30,7 +30,7 @@ from pylegend.core.language import (
     PyLegendStrictDate,
     convert_literal_to_literal_expression,
 )
-from pylegend.core.language.operations.collection_operation_expressions import (
+from pylegend.core.language.shared.operations.collection_operation_expressions import (
     PyLegendCountExpression,
     PyLegendDistinctCountExpression,
     PyLegendAverageExpression,

pylegend/core/language/{primitives → shared/primitives}/__init__.py

@@ -16,15 +16,15 @@
 from pylegend._typing import (
     PyLegendSequence,
 )
-from pylegend.core.language.primitives.primitive import PyLegendPrimitive, PyLegendPrimitiveOrPythonPrimitive
-from pylegend.core.language.primitives.boolean import PyLegendBoolean
-from pylegend.core.language.primitives.string import PyLegendString
-from pylegend.core.language.primitives.number import PyLegendNumber
-from pylegend.core.language.primitives.integer import PyLegendInteger
-from pylegend.core.language.primitives.float import PyLegendFloat
-from pylegend.core.language.primitives.date import PyLegendDate
-from pylegend.core.language.primitives.datetime import PyLegendDateTime
-from pylegend.core.language.primitives.strictdate import PyLegendStrictDate
+from pylegend.core.language.shared.primitives.primitive import PyLegendPrimitive, PyLegendPrimitiveOrPythonPrimitive
+from pylegend.core.language.shared.primitives.boolean import PyLegendBoolean
+from pylegend.core.language.shared.primitives.string import PyLegendString
+from pylegend.core.language.shared.primitives.number import PyLegendNumber
+from pylegend.core.language.shared.primitives.integer import PyLegendInteger
+from pylegend.core.language.shared.primitives.float import PyLegendFloat
+from pylegend.core.language.shared.primitives.date import PyLegendDate
+from pylegend.core.language.shared.primitives.datetime import PyLegendDateTime
+from pylegend.core.language.shared.primitives.strictdate import PyLegendStrictDate
 
 
 __all__: PyLegendSequence[str] = [

pylegend/core/language/{primitives → shared/primitives}/boolean.py

@@ -17,10 +17,10 @@ from pylegend._typing import (
     PyLegendDict,
     PyLegendUnion,
 )
-from pylegend.core.language.primitives.primitive import PyLegendPrimitive
-from pylegend.core.language.expression import PyLegendExpressionBooleanReturn, PyLegendExpression
-from pylegend.core.language.literal_expressions import PyLegendBooleanLiteralExpression
-from pylegend.core.language.operations.boolean_operation_expressions import (
+from pylegend.core.language.shared.primitives.primitive import PyLegendPrimitive
+from pylegend.core.language.shared.expression import PyLegendExpressionBooleanReturn
+from pylegend.core.language.shared.literal_expressions import PyLegendBooleanLiteralExpression
+from pylegend.core.language.shared.operations.boolean_operation_expressions import (
     PyLegendBooleanOrExpression,
     PyLegendBooleanAndExpression,
     PyLegendBooleanNotExpression,
@@ -30,6 +30,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] = [
@@ -53,7 +54,10 @@ class PyLegendBoolean(PyLegendPrimitive):
     ) -> Expression:
         return self.__value.to_sql_expression(frame_name_to_base_query_map, config)
 
-    def value(self) -> PyLegendExpression:
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return self.__value.to_pure_expression(config)
+
+    def value(self) -> PyLegendExpressionBooleanReturn:
         return self.__value
 
     def __or__(self, other: PyLegendUnion[bool, "PyLegendBoolean"]) -> "PyLegendBoolean":

pylegend/core/language/{primitives → shared/primitives}/date.py

@@ -19,17 +19,16 @@ from pylegend._typing import (
     PyLegendUnion,
     TYPE_CHECKING,
 )
-from pylegend.core.language.primitives.primitive import PyLegendPrimitive
-from pylegend.core.language.primitives.integer import PyLegendInteger
-from pylegend.core.language.expression import (
-    PyLegendExpression,
+from pylegend.core.language.shared.primitives.primitive import PyLegendPrimitive
+from pylegend.core.language.shared.primitives.integer import PyLegendInteger
+from pylegend.core.language.shared.expression import (
     PyLegendExpressionDateReturn,
 )
-from pylegend.core.language.literal_expressions import (
+from pylegend.core.language.shared.literal_expressions import (
     PyLegendDateTimeLiteralExpression,
     PyLegendStrictDateLiteralExpression,
 )
-from pylegend.core.language.operations.date_operation_expressions import (
+from pylegend.core.language.shared.operations.date_operation_expressions import (
     PyLegendFirstDayOfYearExpression,
     PyLegendFirstDayOfQuarterExpression,
     PyLegendFirstDayOfMonthExpression,
@@ -49,15 +48,17 @@ from pylegend.core.language.operations.date_operation_expressions import (
     PyLegendMinuteExpression,
     PyLegendSecondExpression,
     PyLegendEpochExpression,
+    PyLegendDatePartExpression,
 )
 from pylegend.core.sql.metamodel import (
     Expression,
     QuerySpecification
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.core.tds.tds_frame import FrameToPureConfig
 if TYPE_CHECKING:
-    from pylegend.core.language.primitives.datetime import PyLegendDateTime
-    from pylegend.core.language.primitives.strictdate import PyLegendStrictDate
+    from pylegend.core.language.shared.primitives.datetime import PyLegendDateTime
+    from pylegend.core.language.shared.primitives.strictdate import PyLegendStrictDate
 
 
 __all__: PyLegendSequence[str] = [
@@ -81,7 +82,10 @@ class PyLegendDate(PyLegendPrimitive):
     ) -> Expression:
         return self.__value.to_sql_expression(frame_name_to_base_query_map, config)
 
-    def value(self) -> PyLegendExpression:
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return self.__value.to_pure_expression(config)
+
+    def value(self) -> PyLegendExpressionDateReturn:
         return self.__value
 
     def first_day_of_year(self) -> "PyLegendDate":
@@ -97,19 +101,19 @@ class PyLegendDate(PyLegendPrimitive):
         return PyLegendDate(PyLegendFirstDayOfWeekExpression(self.__value))
 
     def first_hour_of_day(self) -> "PyLegendDateTime":
-        from pylegend.core.language.primitives.datetime import PyLegendDateTime
+        from pylegend.core.language.shared.primitives.datetime import PyLegendDateTime
         return PyLegendDateTime(PyLegendFirstHourOfDayExpression(self.__value))
 
     def first_minute_of_hour(self) -> "PyLegendDateTime":
-        from pylegend.core.language.primitives.datetime import PyLegendDateTime
+        from pylegend.core.language.shared.primitives.datetime import PyLegendDateTime
         return PyLegendDateTime(PyLegendFirstMinuteOfHourExpression(self.__value))
 
     def first_second_of_minute(self) -> "PyLegendDateTime":
-        from pylegend.core.language.primitives.datetime import PyLegendDateTime
+        from pylegend.core.language.shared.primitives.datetime import PyLegendDateTime
         return PyLegendDateTime(PyLegendFirstSecondOfMinuteExpression(self.__value))
 
     def first_millisecond_of_second(self) -> "PyLegendDateTime":
-        from pylegend.core.language.primitives.datetime import PyLegendDateTime
+        from pylegend.core.language.shared.primitives.datetime import PyLegendDateTime
         return PyLegendDateTime(PyLegendFirstMillisecondOfSecondExpression(self.__value))
 
     def year(self) -> "PyLegendInteger":
@@ -145,6 +149,10 @@ class PyLegendDate(PyLegendPrimitive):
     def day_of_week(self) -> "PyLegendInteger":
         return PyLegendInteger(PyLegendDayOfWeekExpression(self.__value))
 
+    def date_part(self) -> "PyLegendStrictDate":
+        from pylegend.core.language.shared.primitives.strictdate import PyLegendStrictDate
+        return PyLegendStrictDate(PyLegendDatePartExpression(self.__value))
+
     @staticmethod
     def __convert_to_date_expr(
             val: PyLegendUnion[date, datetime, "PyLegendDateTime", "PyLegendStrictDate", "PyLegendDate"]
@@ -160,8 +168,8 @@ class PyLegendDate(PyLegendPrimitive):
             param: PyLegendUnion[date, datetime, "PyLegendDateTime", "PyLegendStrictDate", "PyLegendDate"],
             desc: str
     ) -> None:
-        from pylegend.core.language.primitives.datetime import PyLegendDateTime
-        from pylegend.core.language.primitives.strictdate import PyLegendStrictDate
+        from pylegend.core.language.shared.primitives.datetime import PyLegendDateTime
+        from pylegend.core.language.shared.primitives.strictdate import PyLegendStrictDate
         if not isinstance(param, (date, datetime, PyLegendDateTime, PyLegendStrictDate, PyLegendDate)):
             raise TypeError(desc + " should be a datetime.date/datetime.datetime or a Date expression"
                                    " (PyLegendDateTime/PyLegendStrictDate/PyLegendDate)."

pylegend/core/language/{primitives → shared/primitives}/datetime.py

@@ -18,12 +18,11 @@ from pylegend._typing import (
     PyLegendDict,
     PyLegendUnion,
 )
-from pylegend.core.language.primitives.date import PyLegendDate
-from pylegend.core.language.expression import (
-    PyLegendExpression,
+from pylegend.core.language.shared.primitives.date import PyLegendDate
+from pylegend.core.language.shared.expression import (
     PyLegendExpressionDateTimeReturn,
 )
-from pylegend.core.language.literal_expressions import (
+from pylegend.core.language.shared.literal_expressions import (
     PyLegendDateTimeLiteralExpression,
 )
 from pylegend.core.sql.metamodel import (
@@ -55,7 +54,7 @@ class PyLegendDateTime(PyLegendDate):
     ) -> Expression:
         return self.__value.to_sql_expression(frame_name_to_base_query_map, config)
 
-    def value(self) -> PyLegendExpression:
+    def value(self) -> PyLegendExpressionDateTimeReturn:
         return self.__value
 
     @staticmethod