pylegend 0.9.0__tar.gz → 0.11.0__tar.gz

{pylegend-0.9.0 → pylegend-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pylegend
-Version: 0.9.0
+Version: 0.11.0
 Summary: Python language binding for Legend data management platform
 License: Apache-2.0
 License-File: LICENSE

{pylegend-0.9.0 → pylegend-0.11.0}/pylegend/core/language/shared/functions.py

@@ -16,6 +16,8 @@
 from pylegend._typing import (
     PyLegendSequence,
 )
+from pylegend.core.language import PyLegendNumber
+from pylegend.core.language.shared.operations.number_operation_expressions import PyLegendNumberPiExpression
 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
@@ -32,6 +34,7 @@ __all__: PyLegendSequence[str] = [
     "today",
     "now",
     "current_user",
+    "pi"
 ]
 
 
@@ -45,3 +48,7 @@ def now() -> PyLegendDateTime:
 
 def current_user() -> PyLegendString:
     return PyLegendString(PyLegendCurrentUserExpression())
+
+
+def pi() -> PyLegendNumber:
+    return PyLegendNumber(PyLegendNumberPiExpression())

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

@@ -146,7 +146,13 @@ class PyLegendIntegerModuloExpression(PyLegendBinaryExpression, PyLegendExpressi
             frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
             config: FrameToSqlConfig
     ) -> Expression:
-        return ArithmeticExpression(ArithmeticType.MODULUS, expression1, expression2)
+        return ArithmeticExpression(
+            ArithmeticType.MODULUS,
+            ArithmeticExpression(
+                ArithmeticType.ADD,
+                ArithmeticExpression(ArithmeticType.MODULUS, expression1, expression2),
+                expression2),
+            expression2)
 
     @staticmethod
     def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:

{pylegend-0.9.0 → pylegend-0.11.0}/pylegend/core/language/shared/operations/number_operation_expressions.py

@@ -22,6 +22,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.tds.tds_frame import FrameToSqlConfig
@@ -34,6 +35,8 @@ from pylegend.core.sql.metamodel import (
     ComparisonOperator,
     ComparisonExpression,
     NegativeExpression,
+    FunctionCall,
+    QualifiedName
 )
 from pylegend.core.sql.metamodel_extension import (
     AbsoluteExpression,
@@ -85,6 +88,14 @@ __all__: PyLegendSequence[str] = [
     "PyLegendNumberArcTanExpression",
     "PyLegendNumberArcTan2Expression",
     "PyLegendNumberCotExpression",
+    "PyLegendNumberLog10Expression",
+    "PyLegendNumberDegreesExpression",
+    "PyLegendNumberRadiansExpression",
+    "PyLegendNumberSignExpression",
+    "PyLegendNumberHyperbolicSinExpression",
+    "PyLegendNumberHyperbolicCosExpression",
+    "PyLegendNumberHyperbolicTanExpression",
+    "PyLegendNumberPiExpression"
 ]
 
 
@@ -821,3 +832,256 @@ class PyLegendNumberCotExpression(PyLegendUnaryExpression, PyLegendExpressionNum
             non_nullable=True,
             operand_needs_to_be_non_nullable=True,
         )
+
+
+class PyLegendNumberLog10Expression(PyLegendUnaryExpression, PyLegendExpressionNumberReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["LOG10"]),
+            distinct=False,
+            arguments=[expression],
+            filter_=None,
+            window=None
+        )
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("log10", [op_expr])
+
+    def __init__(self, operand: PyLegendExpressionNumberReturn) -> None:
+        PyLegendExpressionNumberReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendNumberLog10Expression.__to_sql_func,
+            PyLegendNumberLog10Expression.__to_pure_func,
+            non_nullable=True,
+            operand_needs_to_be_non_nullable=True,
+        )
+
+
+class PyLegendNumberDegreesExpression(PyLegendUnaryExpression, PyLegendExpressionNumberReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["DEGREES"]),
+            distinct=False,
+            arguments=[expression],
+            filter_=None,
+            window=None
+        )
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("toDegrees", [op_expr])
+
+    def __init__(self, operand: PyLegendExpressionNumberReturn) -> None:
+        PyLegendExpressionNumberReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendNumberDegreesExpression.__to_sql_func,
+            PyLegendNumberDegreesExpression.__to_pure_func,
+            non_nullable=True,
+            operand_needs_to_be_non_nullable=True,
+        )
+
+
+class PyLegendNumberRadiansExpression(PyLegendUnaryExpression, PyLegendExpressionNumberReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["RADIANS"]),
+            distinct=False,
+            arguments=[expression],
+            filter_=None,
+            window=None
+        )
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("toRadians", [op_expr])
+
+    def __init__(self, operand: PyLegendExpressionNumberReturn) -> None:
+        PyLegendExpressionNumberReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendNumberRadiansExpression.__to_sql_func,
+            PyLegendNumberRadiansExpression.__to_pure_func,
+            non_nullable=True,
+            operand_needs_to_be_non_nullable=True,
+        )
+
+
+class PyLegendNumberSignExpression(PyLegendUnaryExpression, PyLegendExpressionNumberReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["SIGN"]),
+            distinct=False,
+            arguments=[expression],
+            filter_=None,
+            window=None
+        )
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("sign", [op_expr])
+
+    def __init__(self, operand: PyLegendExpressionNumberReturn) -> None:
+        PyLegendExpressionNumberReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendNumberSignExpression.__to_sql_func,
+            PyLegendNumberSignExpression.__to_pure_func,
+            non_nullable=True,
+            operand_needs_to_be_non_nullable=True,
+        )
+
+
+class PyLegendNumberHyperbolicSinExpression(PyLegendUnaryExpression, PyLegendExpressionNumberReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["SINH"]),
+            distinct=False,
+            arguments=[expression],
+            filter_=None,
+            window=None
+        )
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("sinh", [op_expr])
+
+    def __init__(self, operand: PyLegendExpressionNumberReturn) -> None:
+        PyLegendExpressionNumberReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendNumberHyperbolicSinExpression.__to_sql_func,
+            PyLegendNumberHyperbolicSinExpression.__to_pure_func,
+            non_nullable=True,
+            operand_needs_to_be_non_nullable=True,
+        )
+
+
+class PyLegendNumberHyperbolicCosExpression(PyLegendUnaryExpression, PyLegendExpressionNumberReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["COSH"]),
+            distinct=False,
+            arguments=[expression],
+            filter_=None,
+            window=None
+        )
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("cosh", [op_expr])
+
+    def __init__(self, operand: PyLegendExpressionNumberReturn) -> None:
+        PyLegendExpressionNumberReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendNumberHyperbolicCosExpression.__to_sql_func,
+            PyLegendNumberHyperbolicCosExpression.__to_pure_func,
+            non_nullable=True,
+            operand_needs_to_be_non_nullable=True,
+        )
+
+
+class PyLegendNumberHyperbolicTanExpression(PyLegendUnaryExpression, PyLegendExpressionNumberReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["TANH"]),
+            distinct=False,
+            arguments=[expression],
+            filter_=None,
+            window=None
+        )
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("tanh", [op_expr])
+
+    def __init__(self, operand: PyLegendExpressionNumberReturn) -> None:
+        PyLegendExpressionNumberReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendNumberHyperbolicTanExpression.__to_sql_func,
+            PyLegendNumberHyperbolicTanExpression.__to_pure_func,
+            non_nullable=True,
+            operand_needs_to_be_non_nullable=True,
+        )
+
+
+class PyLegendNumberPiExpression(PyLegendNullaryExpression, PyLegendExpressionNumberReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["PI"]),
+            distinct=False,
+            arguments=[],
+            filter_=None,
+            window=None
+        )
+
+    @staticmethod
+    def __to_pure_func(config: FrameToPureConfig) -> str:
+        return "pi()"
+
+    def __init__(self) -> None:
+        PyLegendExpressionNumberReturn.__init__(self)
+        PyLegendNullaryExpression.__init__(
+            self,
+            PyLegendNumberPiExpression.__to_sql_func,
+            PyLegendNumberPiExpression.__to_pure_func,
+            non_nullable=True
+        )

{pylegend-0.9.0 → pylegend-0.11.0}/pylegend/core/language/shared/primitives/number.py

@@ -56,6 +56,13 @@ from pylegend.core.language.shared.operations.number_operation_expressions impor
     PyLegendNumberArcTanExpression,
     PyLegendNumberArcTan2Expression,
     PyLegendNumberCotExpression,
+    PyLegendNumberLog10Expression,
+    PyLegendNumberDegreesExpression,
+    PyLegendNumberRadiansExpression,
+    PyLegendNumberSignExpression,
+    PyLegendNumberHyperbolicSinExpression,
+    PyLegendNumberHyperbolicCosExpression,
+    PyLegendNumberHyperbolicTanExpression
 )
 from pylegend.core.sql.metamodel import (
     Expression,
@@ -290,6 +297,27 @@ class PyLegendNumber(PyLegendPrimitive):
                 raise TypeError("Round parameter should be an int. Passed - " + str(type(n)))
             return PyLegendNumber(PyLegendNumberRoundExpression(self.__value, PyLegendIntegerLiteralExpression(n)))
 
+    def log10(self) -> "PyLegendNumber":
+        return PyLegendNumber(PyLegendNumberLog10Expression(self.__value))
+
+    def degrees(self) -> "PyLegendNumber":
+        return PyLegendNumber(PyLegendNumberDegreesExpression(self.__value))
+
+    def radians(self) -> "PyLegendNumber":
+        return PyLegendNumber(PyLegendNumberRadiansExpression(self.__value))
+
+    def sign(self) -> "PyLegendNumber":
+        return PyLegendNumber(PyLegendNumberSignExpression(self.__value))
+
+    def sinh(self) -> "PyLegendNumber":
+        return PyLegendNumber(PyLegendNumberHyperbolicSinExpression(self.__value))
+
+    def cosh(self) -> "PyLegendNumber":
+        return PyLegendNumber(PyLegendNumberHyperbolicCosExpression(self.__value))
+
+    def tanh(self) -> "PyLegendNumber":
+        return PyLegendNumber(PyLegendNumberHyperbolicTanExpression(self.__value))
+
     def __round__(self, n: PyLegendOptional[int] = None) -> "PyLegendNumber":
         return self.round(n)