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

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,17 @@ 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.primitives.boolean import PyLegendBoolean
+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 +49,21 @@ from pylegend.core.language.operations.date_operation_expressions import (
     PyLegendMinuteExpression,
     PyLegendSecondExpression,
     PyLegendEpochExpression,
+    PyLegendDatePartExpression,
+    PyLegendDateLessThanExpression,
+    PyLegendDateLessThanEqualExpression,
+    PyLegendDateGreaterThanExpression,
+    PyLegendDateGreaterThanEqualExpression,
 )
 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 +87,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 +106,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 +154,42 @@ 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))
+
+    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"]
@@ -160,8 +205,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

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

@@ -18,15 +18,15 @@ from pylegend._typing import (
     PyLegendUnion,
     TYPE_CHECKING,
 )
-from pylegend.core.language.primitives.number import PyLegendNumber
-from pylegend.core.language.expression import PyLegendExpressionFloatReturn, PyLegendExpression
-from pylegend.core.language.literal_expressions import PyLegendFloatLiteralExpression
+from pylegend.core.language.shared.primitives.number import PyLegendNumber
+from pylegend.core.language.shared.expression import PyLegendExpressionFloatReturn
+from pylegend.core.language.shared.literal_expressions import PyLegendFloatLiteralExpression
 from pylegend.core.sql.metamodel import (
     Expression,
     QuerySpecification
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
-from pylegend.core.language.operations.float_operation_expressions import (
+from pylegend.core.language.shared.operations.float_operation_expressions import (
     PyLegendFloatAbsoluteExpression,
     PyLegendFloatAddExpression,
     PyLegendFloatNegativeExpression,
@@ -34,7 +34,7 @@ from pylegend.core.language.operations.float_operation_expressions import (
     PyLegendFloatMultiplyExpression,
 )
 if TYPE_CHECKING:
-    from pylegend.core.language.primitives import PyLegendInteger
+    from pylegend.core.language.shared.primitives import PyLegendInteger
 
 __all__: PyLegendSequence[str] = [
     "PyLegendFloat"
@@ -141,7 +141,7 @@ class PyLegendFloat(PyLegendNumber):
     ) -> Expression:
         return super().to_sql_expression(frame_name_to_base_query_map, config)
 
-    def value(self) -> PyLegendExpression:
+    def value(self) -> PyLegendExpressionFloatReturn:
         return self.__value_copy
 
     @staticmethod

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

@@ -18,15 +18,15 @@ from pylegend._typing import (
     PyLegendUnion,
     TYPE_CHECKING,
 )
-from pylegend.core.language.primitives.number import PyLegendNumber
-from pylegend.core.language.expression import PyLegendExpressionIntegerReturn, PyLegendExpression
-from pylegend.core.language.literal_expressions import PyLegendIntegerLiteralExpression
+from pylegend.core.language.shared.primitives.number import PyLegendNumber
+from pylegend.core.language.shared.expression import PyLegendExpressionIntegerReturn
+from pylegend.core.language.shared.literal_expressions import PyLegendIntegerLiteralExpression
 from pylegend.core.sql.metamodel import (
     Expression,
     QuerySpecification
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
-from pylegend.core.language.operations.integer_operation_expressions import (
+from pylegend.core.language.shared.operations.integer_operation_expressions import (
     PyLegendIntegerAddExpression,
     PyLegendIntegerAbsoluteExpression,
     PyLegendIntegerNegativeExpression,
@@ -35,7 +35,7 @@ from pylegend.core.language.operations.integer_operation_expressions import (
     PyLegendIntegerModuloExpression,
 )
 if TYPE_CHECKING:
-    from pylegend.core.language.primitives import PyLegendFloat
+    from pylegend.core.language.shared.primitives import PyLegendFloat
 
 __all__: PyLegendSequence[str] = [
     "PyLegendInteger"
@@ -59,7 +59,7 @@ class PyLegendInteger(PyLegendNumber):
     ) -> Expression:
         return super().to_sql_expression(frame_name_to_base_query_map, config)
 
-    def value(self) -> PyLegendExpression:
+    def value(self) -> PyLegendExpressionIntegerReturn:
         return self.__value_copy
 
     def __add__(

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

@@ -19,17 +19,16 @@ from pylegend._typing import (
     PyLegendOptional,
     TYPE_CHECKING,
 )
-from pylegend.core.language.primitives.primitive import PyLegendPrimitive
-from pylegend.core.language.primitives.boolean import PyLegendBoolean
-from pylegend.core.language.expression import (
-    PyLegendExpression,
+from pylegend.core.language.shared.primitives.primitive import PyLegendPrimitive
+from pylegend.core.language.shared.primitives.boolean import PyLegendBoolean
+from pylegend.core.language.shared.expression import (
     PyLegendExpressionNumberReturn,
 )
-from pylegend.core.language.literal_expressions import (
+from pylegend.core.language.shared.literal_expressions import (
     PyLegendIntegerLiteralExpression,
     PyLegendFloatLiteralExpression,
 )
-from pylegend.core.language.operations.number_operation_expressions import (
+from pylegend.core.language.shared.operations.number_operation_expressions import (
     PyLegendNumberAddExpression,
     PyLegendNumberMultiplyExpression,
     PyLegendNumberDivideExpression,
@@ -63,9 +62,10 @@ from pylegend.core.sql.metamodel import (
     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.integer import PyLegendInteger
-    from pylegend.core.language.primitives.float import PyLegendFloat
+    from pylegend.core.language.shared.primitives.integer import PyLegendInteger
+    from pylegend.core.language.shared.primitives.float import PyLegendFloat
 
 
 __all__: PyLegendSequence[str] = [
@@ -89,7 +89,10 @@ class PyLegendNumber(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) -> PyLegendExpressionNumberReturn:
         return self.__value
 
     def __add__(
@@ -214,14 +217,14 @@ class PyLegendNumber(PyLegendPrimitive):
         return PyLegendNumber(PyLegendNumberPowerExpression(other_op, self.__value))
 
     def ceil(self) -> "PyLegendInteger":
-        from pylegend.core.language.primitives.integer import PyLegendInteger
+        from pylegend.core.language.shared.primitives.integer import PyLegendInteger
         return PyLegendInteger(PyLegendNumberCeilExpression(self.__value))
 
     def __ceil__(self) -> "PyLegendInteger":
         return self.ceil()
 
     def floor(self) -> "PyLegendInteger":
-        from pylegend.core.language.primitives.integer import PyLegendInteger
+        from pylegend.core.language.shared.primitives.integer import PyLegendInteger
         return PyLegendInteger(PyLegendNumberFloorExpression(self.__value))
 
     def __floor__(self) -> "PyLegendInteger":
@@ -305,8 +308,8 @@ class PyLegendNumber(PyLegendPrimitive):
             param: PyLegendUnion[int, float, "PyLegendInteger", "PyLegendFloat", "PyLegendNumber"],
             desc: str
     ) -> None:
-        from pylegend.core.language.primitives.integer import PyLegendInteger
-        from pylegend.core.language.primitives.float import PyLegendFloat
+        from pylegend.core.language.shared.primitives.integer import PyLegendInteger
+        from pylegend.core.language.shared.primitives.float import PyLegendFloat
         if not isinstance(param, (int, float, PyLegendInteger, PyLegendFloat, PyLegendNumber)):
             raise TypeError(desc + " should be a int/float or a int/float/number expression"
                                    " (PyLegendInteger/PyLegendFloat/PyLegendNumber)."

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

@@ -25,14 +25,18 @@ from pylegend.core.sql.metamodel import (
     Expression,
     QuerySpecification
 )
-from pylegend.core.language.expression import PyLegendExpression
-from pylegend.core.language.literal_expressions import convert_literal_to_literal_expression
-from pylegend.core.language.operations.primitive_operation_expressions import (
+from pylegend.core.language.shared.expression import PyLegendExpression
+from pylegend.core.language.shared.literal_expressions import convert_literal_to_literal_expression
+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
 if TYPE_CHECKING:
-    from pylegend.core.language.primitives.boolean import PyLegendBoolean
+    from pylegend.core.language.shared.primitives.boolean import PyLegendBoolean
 
 __all__: PyLegendSequence[str] = [
     "PyLegendPrimitive",
@@ -50,6 +54,10 @@ class PyLegendPrimitive(metaclass=ABCMeta):
     ) -> Expression:
         pass
 
+    @abstractmethod
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        pass
+
     def __eq__(  # type: ignore
             self,
             other: "PyLegendUnion[int, float, bool, str, date, datetime, PyLegendPrimitive]"
@@ -61,9 +69,37 @@ class PyLegendPrimitive(metaclass=ABCMeta):
         else:
             other_op = other.value()
 
-        from pylegend.core.language.primitives.boolean import PyLegendBoolean
+        from pylegend.core.language.shared.primitives.boolean import PyLegendBoolean
         return PyLegendBoolean(PyLegendPrimitiveEqualsExpression(self.value(), other_op))
 
+    def __ne__(  # type: ignore
+            self,
+            other: "PyLegendUnion[int, float, bool, str, date, datetime, PyLegendPrimitive]"
+    ) -> "PyLegendBoolean":
+        PyLegendPrimitive.__validate_param_to_be_primitive(other, "Not Equals (!=) parameter")
+
+        if isinstance(other, (int, float, bool, str, date, datetime)):
+            other_op = convert_literal_to_literal_expression(other)
+        else:
+            other_op = other.value()
+
+        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/core/language/{primitives → shared/primitives}/strictdate.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 (
     PyLegendExpressionStrictDateReturn,
 )
-from pylegend.core.language.literal_expressions import (
+from pylegend.core.language.shared.literal_expressions import (
     PyLegendStrictDateLiteralExpression,
 )
 from pylegend.core.sql.metamodel import (
@@ -55,7 +54,7 @@ class PyLegendStrictDate(PyLegendDate):
     ) -> Expression:
         return self.__value.to_sql_expression(frame_name_to_base_query_map, config)
 
-    def value(self) -> PyLegendExpression:
+    def value(self) -> PyLegendExpressionStrictDateReturn:
         return self.__value
 
     @staticmethod

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

@@ -17,20 +17,23 @@ from pylegend._typing import (
     PyLegendDict,
     PyLegendUnion,
 )
-from pylegend.core.language.primitives.primitive import PyLegendPrimitive
-from pylegend.core.language.primitives.integer import PyLegendInteger
-from pylegend.core.language.primitives.float import PyLegendFloat
-from pylegend.core.language.primitives.boolean import PyLegendBoolean
-from pylegend.core.language.expression import PyLegendExpressionStringReturn, PyLegendExpression
-from pylegend.core.language.literal_expressions import PyLegendStringLiteralExpression
+from pylegend.core.language.shared.primitives.primitive import PyLegendPrimitive
+from pylegend.core.language.shared.primitives.integer import PyLegendInteger
+from pylegend.core.language.shared.primitives.float import PyLegendFloat
+from pylegend.core.language.shared.primitives.boolean import PyLegendBoolean
+from pylegend.core.language.shared.expression import PyLegendExpressionStringReturn
+from pylegend.core.language.shared.literal_expressions import PyLegendStringLiteralExpression
 from pylegend.core.sql.metamodel import (
     Expression,
     QuerySpecification
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
-from pylegend.core.language.operations.string_operation_expressions import (
+from pylegend.core.tds.tds_frame import FrameToPureConfig
+from pylegend.core.language.shared.operations.string_operation_expressions import (
     PyLegendStringLengthExpression,
-    PyLegendStringLikeExpression,
+    PyLegendStringStartsWithExpression,
+    PyLegendStringEndsWithExpression,
+    PyLegendStringContainsExpression,
     PyLegendStringUpperExpression,
     PyLegendStringLowerExpression,
     PyLegendStringLTrimExpression,
@@ -69,23 +72,20 @@ class PyLegendString(PyLegendPrimitive):
 
     def startswith(self, prefix: str) -> PyLegendBoolean:
         PyLegendString.__validate_param_to_be_str(prefix, "startswith prefix parameter")
-        escaped_prefix = PyLegendString.__escape_like_param(prefix)
         return PyLegendBoolean(
-            PyLegendStringLikeExpression(self.__value, PyLegendStringLiteralExpression(escaped_prefix + '%'))
+            PyLegendStringStartsWithExpression(self.__value, PyLegendStringLiteralExpression(prefix))
         )
 
     def endswith(self, suffix: str) -> PyLegendBoolean:
         PyLegendString.__validate_param_to_be_str(suffix, "endswith suffix parameter")
-        escaped_suffix = PyLegendString.__escape_like_param(suffix)
         return PyLegendBoolean(
-            PyLegendStringLikeExpression(self.__value, PyLegendStringLiteralExpression("%" + escaped_suffix))
+            PyLegendStringEndsWithExpression(self.__value, PyLegendStringLiteralExpression(suffix))
         )
 
     def contains(self, other: str) -> PyLegendBoolean:
         PyLegendString.__validate_param_to_be_str(other, "contains/in other parameter")
-        escaped_other = PyLegendString.__escape_like_param(other)
         return PyLegendBoolean(
-            PyLegendStringLikeExpression(self.__value, PyLegendStringLiteralExpression("%" + escaped_other + "%"))
+            PyLegendStringContainsExpression(self.__value, PyLegendStringLiteralExpression(other))
         )
 
     def upper(self) -> "PyLegendString":
@@ -157,12 +157,11 @@ class PyLegendString(PyLegendPrimitive):
     ) -> Expression:
         return self.__value.to_sql_expression(frame_name_to_base_query_map, config)
 
-    def value(self) -> PyLegendExpression:
-        return self.__value
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return self.__value.to_pure_expression(config)
 
-    @staticmethod
-    def __escape_like_param(param: str) -> str:
-        return param.replace("_", "\\_").replace("%", "\\%")
+    def value(self) -> PyLegendExpressionStringReturn:
+        return self.__value
 
     @staticmethod
     def __validate_param_to_be_str_or_str_expr(param: PyLegendUnion[str, "PyLegendString"], desc: str) -> None:

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

@@ -1,4 +1,4 @@
-# Copyright 2023 Goldman Sachs
+# Copyright 2025 Goldman Sachs
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,10 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from abc import ABCMeta
 from pylegend._typing import (
     PyLegendSequence,
+    PyLegendDict,
+)
+from pylegend.core.sql.metamodel import (
+    QuerySpecification,
+    Expression,
+    SingleColumn,
+)
+from pylegend.core.tds.tds_frame import (
+    PyLegendTdsFrame,
+    FrameToPureConfig,
+    FrameToSqlConfig,
 )
-from pylegend.core.tds.tds_frame import PyLegendTdsFrame
 from pylegend.core.tds.tds_column import TdsColumn, PrimitiveTdsColumn
 from pylegend.core.language import (
     PyLegendColumnExpression,
@@ -39,11 +50,11 @@ from pylegend.core.language import (
 )
 
 __all__: PyLegendSequence[str] = [
-    "TdsRow",
+    "AbstractTdsRow",
 ]
 
 
-class TdsRow:
+class AbstractTdsRow(metaclass=ABCMeta):
     __frame_name: str
     __columns: PyLegendSequence[TdsColumn]
 
@@ -51,10 +62,6 @@ class TdsRow:
         self.__frame_name = frame_name
         self.__columns = frame.columns()
 
-    @staticmethod
-    def from_tds_frame(frame_name: str, frame: PyLegendTdsFrame) -> "TdsRow":
-        return TdsRow(frame_name=frame_name, frame=frame)
-
     def get_boolean(self, column: str) -> PyLegendBoolean:
         col_expr = self.__get_col(column)
         if not isinstance(col_expr, PyLegendBooleanColumnExpression):
@@ -161,21 +168,21 @@ class TdsRow:
             if base_col.get_name() == column:
                 if isinstance(base_col, PrimitiveTdsColumn):
                     if base_col.get_type() == "Boolean":
-                        return PyLegendBooleanColumnExpression(self.__frame_name, column)
+                        return PyLegendBooleanColumnExpression(self, column)
                     if base_col.get_type() == "String":
-                        return PyLegendStringColumnExpression(self.__frame_name, column)
+                        return PyLegendStringColumnExpression(self, column)
                     if base_col.get_type() == "Number":
-                        return PyLegendNumberColumnExpression(self.__frame_name, column)
+                        return PyLegendNumberColumnExpression(self, column)
                     if base_col.get_type() == "Integer":
-                        return PyLegendIntegerColumnExpression(self.__frame_name, column)
+                        return PyLegendIntegerColumnExpression(self, column)
                     if base_col.get_type() == "Float":
-                        return PyLegendFloatColumnExpression(self.__frame_name, column)
+                        return PyLegendFloatColumnExpression(self, column)
                     if base_col.get_type() == "Date":
-                        return PyLegendDateColumnExpression(self.__frame_name, column)
+                        return PyLegendDateColumnExpression(self, column)
                     if base_col.get_type() == "DateTime":
-                        return PyLegendDateTimeColumnExpression(self.__frame_name, column)
+                        return PyLegendDateTimeColumnExpression(self, column)
                     if base_col.get_type() == "StrictDate":
-                        return PyLegendStrictDateColumnExpression(self.__frame_name, column)
+                        return PyLegendStrictDateColumnExpression(self, column)
 
                 raise RuntimeError(f"Column '{column}' of type {base_col.get_type()} not supported yet")
 
@@ -183,3 +190,26 @@ class TdsRow:
             f"Column - '{column}' doesn't exist in the current frame. "
             f"Current frame columns: {[x.get_name() for x in self.__columns]}"
         )
+
+    def get_frame_name(self) -> str:
+        return self.__frame_name
+
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return f"${self.__frame_name}"
+
+    def column_sql_expression(
+            self,
+            column: str,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        query = frame_name_to_base_query_map[self.__frame_name]
+        db_extension = config.sql_to_string_generator().get_db_extension()
+        filtered = [
+            s for s in query.select.selectItems
+            if (isinstance(s, SingleColumn) and
+                s.alias == db_extension.quote_identifier(column))
+        ]
+        if len(filtered) == 0:
+            raise RuntimeError("Cannot find column: " + column)  # pragma: no cover
+        return filtered[0].expression

pylegend/core/request/__init__.py

@@ -16,7 +16,12 @@ from pylegend._typing import (
     PyLegendSequence,
 )
 from pylegend.core.request.legend_client import LegendClient
-from pylegend.core.request.auth import AuthScheme, LocalhostEmptyAuthScheme, HeaderTokenAuthScheme
+from pylegend.core.request.auth import (
+    AuthScheme,
+    LocalhostEmptyAuthScheme,
+    HeaderTokenAuthScheme,
+    CookieAuthScheme,
+)
 from pylegend.core.request.response_reader import ResponseReader
 
 __all__: PyLegendSequence[str] = [
@@ -25,6 +30,7 @@ __all__: PyLegendSequence[str] = [
     "AuthScheme",
     "LocalhostEmptyAuthScheme",
     "HeaderTokenAuthScheme",
+    "CookieAuthScheme",
 
     "ResponseReader"
 ]