pylegend 0.4.0__tar.gz → 0.6.0__tar.gz

{pylegend-0.4.0 → pylegend-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pylegend
-Version: 0.4.0
+Version: 0.6.0
 Summary: Python language binding for Legend data management platform
 License: Apache-2.0
 Author: PyLegend Maintainers

{pylegend-0.4.0 → pylegend-0.6.0}/pylegend/__init__.py

@@ -32,7 +32,12 @@ from pylegend.core.project_cooridnates import (
     PersonalWorkspaceProjectCoordinates,
     GroupWorkspaceProjectCoordinates,
 )
-from pylegend.core.language import agg
+from pylegend.core.language import (
+    agg,
+    now,
+    today,
+    current_user,
+)
 
 
 __all__: PyLegendSequence[str] = [
@@ -53,6 +58,9 @@ __all__: PyLegendSequence[str] = [
     "GroupWorkspaceProjectCoordinates",
 
     "agg",
+    "now",
+    "today",
+    "current_user",
 ]
 
 

{pylegend-0.4.0 → pylegend-0.6.0}/pylegend/core/database/sql_to_string/db_extension.py

@@ -131,6 +131,7 @@ from pylegend.core.sql.metamodel_extension import (
     SecondExpression,
     EpochExpression,
     WindowExpression,
+    ConstantExpression,
 )
 
 
@@ -451,6 +452,8 @@ def expression_processor(
         return extension.process_epoch_expression(expression, config)
     elif isinstance(expression, WindowExpression):
         return extension.process_window_expression(expression, config)
+    elif isinstance(expression, ConstantExpression):
+        return expression.name
 
     else:
         raise ValueError("Unsupported expression type: " + str(type(expression)))  # pragma: no cover

{pylegend-0.4.0 → pylegend-0.6.0}/pylegend/core/language/__init__.py

@@ -74,6 +74,7 @@ from pylegend.core.language.shared.primitive_collection import (
 from pylegend.core.language.shared.functions import (
     today,
     now,
+    current_user,
 )
 
 __all__: PyLegendSequence[str] = [
@@ -132,4 +133,5 @@ __all__: PyLegendSequence[str] = [
 
     "today",
     "now",
+    "current_user",
 ]

{pylegend-0.4.0 → pylegend-0.6.0}/pylegend/core/language/shared/functions.py

@@ -18,15 +18,20 @@ from pylegend._typing 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-0.4.0 → pylegend-0.6.0}/pylegend/core/language/shared/helpers.py

@@ -24,8 +24,7 @@ __all__ = [
 def generate_pure_functional_call(
         func: str,
         params: PyLegendList[str],
-        force_prefix: bool = False,
-        auto_map: bool = False
+        force_prefix: bool = False
 ) -> str:
     should_prefix = force_prefix or (len(params) == 0)
 
@@ -39,13 +38,6 @@ def generate_pure_functional_call(
         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:

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

@@ -43,6 +43,9 @@ class PyLegendBinaryExpression(PyLegendExpression, metaclass=ABCMeta):
         Expression
     ]
     __to_pure_func: PyLegendCallable[[str, str, FrameToPureConfig], str]
+    __non_nullable: bool
+    __first_operand_needs_to_be_non_nullable: bool
+    __second_operand_needs_to_be_non_nullable: bool
 
     def __init__(
             self,
@@ -52,12 +55,18 @@ class PyLegendBinaryExpression(PyLegendExpression, metaclass=ABCMeta):
                 [Expression, Expression, PyLegendDict[str, QuerySpecification], FrameToSqlConfig],
                 Expression
             ],
-            to_pure_func: PyLegendCallable[[str, str, FrameToPureConfig], str]
+            to_pure_func: PyLegendCallable[[str, str, FrameToPureConfig], str],
+            non_nullable: bool = False,
+            first_operand_needs_to_be_non_nullable: bool = False,
+            second_operand_needs_to_be_non_nullable: bool = False,
     ) -> None:
         self.__operand1 = operand1
         self.__operand2 = operand2
         self.__to_sql_func = to_sql_func
         self.__to_pure_func = to_pure_func
+        self.__non_nullable = non_nullable
+        self.__first_operand_needs_to_be_non_nullable = first_operand_needs_to_be_non_nullable
+        self.__second_operand_needs_to_be_non_nullable = second_operand_needs_to_be_non_nullable
 
     def to_sql_expression(
             self,
@@ -75,27 +84,18 @@ class PyLegendBinaryExpression(PyLegendExpression, metaclass=ABCMeta):
 
     def to_pure_expression(self, config: FrameToPureConfig) -> str:
         op1_expr = self.__operand1.to_pure_expression(config)
+        if self.__first_operand_needs_to_be_non_nullable:
+            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)
+        if self.__second_operand_needs_to_be_non_nullable:
+            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_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)
+    def is_non_nullable(self) -> bool:
+        return self.__non_nullable

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

@@ -19,6 +19,7 @@ from pylegend._typing import (
 from pylegend.core.language.shared.expression import (
     PyLegendExpressionBooleanReturn,
 )
+from pylegend.core.language.shared.helpers import generate_pure_functional_call
 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 (
@@ -61,15 +62,12 @@ class PyLegendBooleanOrExpression(PyLegendBinaryExpression, PyLegendExpressionBo
             operand1,
             operand2,
             PyLegendBooleanOrExpression.__to_sql_func,
-            PyLegendBooleanOrExpression.__to_pure_func
+            PyLegendBooleanOrExpression.__to_pure_func,
+            non_nullable=True,
+            first_operand_needs_to_be_non_nullable=True,
+            second_operand_needs_to_be_non_nullable=True
         )
 
-    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):
 
@@ -93,15 +91,12 @@ class PyLegendBooleanAndExpression(PyLegendBinaryExpression, PyLegendExpressionB
             operand1,
             operand2,
             PyLegendBooleanAndExpression.__to_sql_func,
-            PyLegendBooleanAndExpression.__to_pure_func
+            PyLegendBooleanAndExpression.__to_pure_func,
+            non_nullable=True,
+            first_operand_needs_to_be_non_nullable=True,
+            second_operand_needs_to_be_non_nullable=True
         )
 
-    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):
 
@@ -115,7 +110,7 @@ class PyLegendBooleanNotExpression(PyLegendUnaryExpression, PyLegendExpressionBo
 
     @staticmethod
     def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
-        return f"{op_expr}->map(op | !$op)"
+        return generate_pure_functional_call("not", [op_expr])
 
     def __init__(self, operand: PyLegendExpressionBooleanReturn) -> None:
         PyLegendExpressionBooleanReturn.__init__(self)
@@ -123,5 +118,7 @@ class PyLegendBooleanNotExpression(PyLegendUnaryExpression, PyLegendExpressionBo
             self,
             operand,
             PyLegendBooleanNotExpression.__to_sql_func,
-            PyLegendBooleanNotExpression.__to_pure_func
+            PyLegendBooleanNotExpression.__to_pure_func,
+            non_nullable=True,
+            operand_needs_to_be_non_nullable=True,
         )