pylegend 0.4.0__tar.gz → 0.5.0__tar.gz

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

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

{pylegend-0.4.0 → pylegend-0.5.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.5.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.5.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.5.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.5.0}/pylegend/core/language/shared/operations/date_operation_expressions.py

@@ -21,7 +21,9 @@ from pylegend.core.language.shared.expression import (
     PyLegendExpressionDateTimeReturn,
     PyLegendExpressionStrictDateReturn,
     PyLegendExpressionIntegerReturn,
+    PyLegendExpressionBooleanReturn,
 )
+from pylegend.core.language.shared.operations.binary_expression import PyLegendBinaryExpression
 from pylegend.core.language.shared.operations.nullary_expression import PyLegendNullaryExpression
 from pylegend.core.language.shared.operations.unary_expression import PyLegendUnaryExpression
 from pylegend.core.language.shared.helpers import generate_pure_functional_call
@@ -36,6 +38,8 @@ from pylegend.core.sql.metamodel import (
     CurrentTimeType,
     Cast,
     ColumnType,
+    ComparisonExpression,
+    ComparisonOperator,
 )
 from pylegend.core.sql.metamodel_extension import (
     FirstDayOfYearExpression,
@@ -83,6 +87,10 @@ __all__: PyLegendSequence[str] = [
     "PyLegendTodayExpression",
     "PyLegendNowExpression",
     "PyLegendDatePartExpression",
+    "PyLegendDateLessThanExpression",
+    "PyLegendDateLessThanEqualExpression",
+    "PyLegendDateGreaterThanExpression",
+    "PyLegendDateGreaterThanEqualExpression",
 ]
 
 
@@ -614,3 +622,119 @@ class PyLegendDatePartExpression(PyLegendUnaryExpression, PyLegendExpressionStri
             PyLegendDatePartExpression.__to_sql_func,
             PyLegendDatePartExpression.__to_pure_func
         )
+
+
+class PyLegendDateLessThanExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> 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: PyLegendExpressionDateReturn, operand2: PyLegendExpressionDateReturn) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendDateLessThanExpression.__to_sql_func,
+            PyLegendDateLessThanExpression.__to_pure_func
+        )
+
+    def is_non_nullable(self) -> bool:
+        return True
+
+
+class PyLegendDateLessThanEqualExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> 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: PyLegendExpressionDateReturn, operand2: PyLegendExpressionDateReturn) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendDateLessThanEqualExpression.__to_sql_func,
+            PyLegendDateLessThanEqualExpression.__to_pure_func
+        )
+
+    def is_non_nullable(self) -> bool:
+        return True
+
+
+class PyLegendDateGreaterThanExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> 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: PyLegendExpressionDateReturn, operand2: PyLegendExpressionDateReturn) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendDateGreaterThanExpression.__to_sql_func,
+            PyLegendDateGreaterThanExpression.__to_pure_func
+        )
+
+    def is_non_nullable(self) -> bool:
+        return True
+
+
+class PyLegendDateGreaterThanEqualExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> 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: PyLegendExpressionDateReturn, operand2: PyLegendExpressionDateReturn) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendDateGreaterThanEqualExpression.__to_sql_func,
+            PyLegendDateGreaterThanEqualExpression.__to_pure_func
+        )
+
+    def is_non_nullable(self) -> bool:
+        return True

{pylegend-0.4.0 → pylegend-0.5.0}/pylegend/core/language/shared/operations/primitive_operation_expressions.py

@@ -20,12 +20,16 @@ from pylegend.core.language.shared.expression import (
     PyLegendExpression,
     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 (
     Expression,
     QuerySpecification,
     ComparisonExpression,
     ComparisonOperator,
+    IsNullPredicate,
+    IsNotNullPredicate,
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
 from pylegend.core.tds.tds_frame import FrameToPureConfig
@@ -34,6 +38,8 @@ from pylegend.core.tds.tds_frame import FrameToPureConfig
 __all__: PyLegendSequence[str] = [
     "PyLegendPrimitiveEqualsExpression",
     "PyLegendPrimitiveNotEqualsExpression",
+    "PyLegendIsEmptyExpression",
+    "PyLegendIsNotEmptyExpression",
 ]
 
 
@@ -93,3 +99,57 @@ class PyLegendPrimitiveNotEqualsExpression(PyLegendBinaryExpression, PyLegendExp
 
     def is_non_nullable(self) -> bool:
         return True
+
+
+class PyLegendIsEmptyExpression(PyLegendUnaryExpression, PyLegendExpressionBooleanReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return IsNullPredicate(expression)
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("isEmpty", [op_expr])
+
+    def __init__(self, operand: PyLegendExpression) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendIsEmptyExpression.__to_sql_func,
+            PyLegendIsEmptyExpression.__to_pure_func
+        )
+
+    def is_non_nullable(self) -> bool:
+        return True
+
+
+class PyLegendIsNotEmptyExpression(PyLegendUnaryExpression, PyLegendExpressionBooleanReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return IsNotNullPredicate(expression)
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("isNotEmpty", [op_expr])
+
+    def __init__(self, operand: PyLegendExpression) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendIsNotEmptyExpression.__to_sql_func,
+            PyLegendIsNotEmptyExpression.__to_pure_func
+        )
+
+    def is_non_nullable(self) -> bool:
+        return True

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

@@ -23,6 +23,7 @@ from pylegend.core.language.shared.expression import (
     PyLegendExpressionBooleanReturn,
 )
 from pylegend.core.language.shared.operations.binary_expression import PyLegendBinaryExpression
+from pylegend.core.language.shared.operations.nullary_expression import PyLegendNullaryExpression
 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 (
@@ -43,6 +44,7 @@ from pylegend.core.sql.metamodel_extension import (
     StringTrimExpression,
     StringPosExpression,
     StringConcatExpression,
+    ConstantExpression,
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
 from pylegend.core.tds.tds_frame import FrameToPureConfig
@@ -66,6 +68,7 @@ __all__: PyLegendSequence[str] = [
     "PyLegendStringLessThanEqualExpression",
     "PyLegendStringGreaterThanExpression",
     "PyLegendStringGreaterThanEqualExpression",
+    "PyLegendCurrentUserExpression",
 ]
 
 
@@ -507,5 +510,27 @@ class PyLegendStringGreaterThanEqualExpression(PyLegendBinaryExpression, PyLegen
         )
 
 
+class PyLegendCurrentUserExpression(PyLegendNullaryExpression, PyLegendExpressionStringReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return ConstantExpression('CURRENT_USER')
+
+    @staticmethod
+    def __to_pure_func(config: FrameToPureConfig) -> str:
+        return "currentUserId()"
+
+    def __init__(self) -> None:
+        PyLegendExpressionStringReturn.__init__(self)
+        PyLegendNullaryExpression.__init__(
+            self,
+            PyLegendCurrentUserExpression.__to_sql_func,
+            PyLegendCurrentUserExpression.__to_pure_func
+        )
+
+
 def _escape_like_param(param: str) -> str:
     return param.replace("_", "\\_").replace("%", "\\%")

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

@@ -21,6 +21,7 @@ from pylegend._typing import (
 )
 from pylegend.core.language.shared.primitives.primitive import PyLegendPrimitive
 from pylegend.core.language.shared.primitives.integer import PyLegendInteger
+from pylegend.core.language.shared.primitives.boolean import PyLegendBoolean
 from pylegend.core.language.shared.expression import (
     PyLegendExpressionDateReturn,
 )
@@ -49,6 +50,10 @@ from pylegend.core.language.shared.operations.date_operation_expressions import
     PyLegendSecondExpression,
     PyLegendEpochExpression,
     PyLegendDatePartExpression,
+    PyLegendDateLessThanExpression,
+    PyLegendDateLessThanEqualExpression,
+    PyLegendDateGreaterThanExpression,
+    PyLegendDateGreaterThanEqualExpression,
 )
 from pylegend.core.sql.metamodel import (
     Expression,
@@ -153,6 +158,38 @@ class PyLegendDate(PyLegendPrimitive):
         from pylegend.core.language.shared.primitives.strictdate import PyLegendStrictDate
         return PyLegendStrictDate(PyLegendDatePartExpression(self.__value))
 
+    def __lt__(
+            self,
+            other: PyLegendUnion[date, datetime, "PyLegendStrictDate", "PyLegendDateTime", "PyLegendDate"]
+    ) -> "PyLegendBoolean":
+        PyLegendDate.validate_param_to_be_date(other, "Date less than (<) parameter")
+        other_op = PyLegendDate.__convert_to_date_expr(other)
+        return PyLegendBoolean(PyLegendDateLessThanExpression(self.__value, other_op))
+
+    def __le__(
+            self,
+            other: PyLegendUnion[date, datetime, "PyLegendStrictDate", "PyLegendDateTime", "PyLegendDate"]
+    ) -> "PyLegendBoolean":
+        PyLegendDate.validate_param_to_be_date(other, "Date less than equal (<=) parameter")
+        other_op = PyLegendDate.__convert_to_date_expr(other)
+        return PyLegendBoolean(PyLegendDateLessThanEqualExpression(self.__value, other_op))
+
+    def __gt__(
+            self,
+            other: PyLegendUnion[date, datetime, "PyLegendStrictDate", "PyLegendDateTime", "PyLegendDate"]
+    ) -> "PyLegendBoolean":
+        PyLegendDate.validate_param_to_be_date(other, "Date greater than (>) parameter")
+        other_op = PyLegendDate.__convert_to_date_expr(other)
+        return PyLegendBoolean(PyLegendDateGreaterThanExpression(self.__value, other_op))
+
+    def __ge__(
+            self,
+            other: PyLegendUnion[date, datetime, "PyLegendStrictDate", "PyLegendDateTime", "PyLegendDate"]
+    ) -> "PyLegendBoolean":
+        PyLegendDate.validate_param_to_be_date(other, "Date greater than equal (>=) parameter")
+        other_op = PyLegendDate.__convert_to_date_expr(other)
+        return PyLegendBoolean(PyLegendDateGreaterThanEqualExpression(self.__value, other_op))
+
     @staticmethod
     def __convert_to_date_expr(
             val: PyLegendUnion[date, datetime, "PyLegendDateTime", "PyLegendStrictDate", "PyLegendDate"]

{pylegend-0.4.0 → pylegend-0.5.0}/pylegend/core/language/shared/primitives/primitive.py

@@ -30,6 +30,8 @@ from pylegend.core.language.shared.literal_expressions import convert_literal_to
 from pylegend.core.language.shared.operations.primitive_operation_expressions import (
     PyLegendPrimitiveEqualsExpression,
     PyLegendPrimitiveNotEqualsExpression,
+    PyLegendIsEmptyExpression,
+    PyLegendIsNotEmptyExpression,
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
 from pylegend.core.tds.tds_frame import FrameToPureConfig
@@ -84,6 +86,20 @@ class PyLegendPrimitive(metaclass=ABCMeta):
         from pylegend.core.language.shared.primitives.boolean import PyLegendBoolean
         return PyLegendBoolean(PyLegendPrimitiveNotEqualsExpression(self.value(), other_op))
 
+    def is_empty(self) -> "PyLegendBoolean":
+        from pylegend.core.language.shared.primitives.boolean import PyLegendBoolean
+        return PyLegendBoolean(PyLegendIsEmptyExpression(self.value()))
+
+    def is_null(self) -> "PyLegendBoolean":
+        return self.is_empty()
+
+    def is_not_empty(self) -> "PyLegendBoolean":
+        from pylegend.core.language.shared.primitives.boolean import PyLegendBoolean
+        return PyLegendBoolean(PyLegendIsNotEmptyExpression(self.value()))
+
+    def is_not_null(self) -> "PyLegendBoolean":
+        return self.is_not_empty()
+
     @staticmethod
     def __validate_param_to_be_primitive(
             param: "PyLegendUnion[int, float, bool, str, date, datetime, PyLegendPrimitive]",

{pylegend-0.4.0 → pylegend-0.5.0}/pylegend/core/sql/metamodel_extension.py

@@ -80,6 +80,7 @@ __all__: PyLegendSequence[str] = [
     "SecondExpression",
     "EpochExpression",
     "WindowExpression",
+    "ConstantExpression",
 ]
 
 
@@ -733,3 +734,14 @@ class WindowExpression(Expression):
         super().__init__(_type="windowExpression")
         self.nested = nested
         self.window = window
+
+
+class ConstantExpression(Expression):
+    name: str
+
+    def __init__(
+        self,
+        name: str
+    ) -> None:
+        super().__init__(_type="constantExpression")
+        self.name = name

{pylegend-0.4.0 → pylegend-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pylegend"
-version = "0.4.0"
+version = "0.5.0"
 description = "Python language binding for Legend data management platform"
 authors = ["PyLegend Maintainers <legend@finos.org>"]
 license = "Apache-2.0"