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

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,16 @@ 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,
 )
 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 +52,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 +67,23 @@ 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))
+
     @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"
 ]

pylegend/core/request/auth.py

@@ -15,6 +15,7 @@
 from abc import ABCMeta, abstractmethod
 
 from requests import PreparedRequest
+from requests.cookies import create_cookie
 
 from pylegend._typing import (
     PyLegendSequence,
@@ -27,7 +28,8 @@ from requests.auth import AuthBase
 __all__: PyLegendSequence[str] = [
     "AuthScheme",
     "LocalhostEmptyAuthScheme",
-    "HeaderTokenAuthScheme"
+    "HeaderTokenAuthScheme",
+    "CookieAuthScheme",
 ]
 
 
@@ -83,3 +85,55 @@ class HeaderTokenAuthScheme(AuthScheme):
 
     def get_auth_base(self) -> PyLegendOptional[AuthBase]:
         return HeaderTokenAuth(self.__header_name, self.__token_provider, self.__query_params)
+
+
+class CookieAuth(AuthBase):
+    __cookie_name: str
+    __cookie_provider: PyLegendCallable[[], str]
+    __query_params: PyLegendOptional[PyLegendDict[str, str]]
+
+    def __init__(  # type: ignore
+            self,
+            cookie_name: str,
+            cookie_provider: PyLegendCallable[[], str],
+            query_params: PyLegendOptional[PyLegendDict[str, str]] = None,
+            **extra_cookie_params
+    ) -> None:
+        self.__cookie_name = cookie_name
+        self.__cookie_provider = cookie_provider
+        self.__query_params = query_params
+        self.__extra_cookie_params = extra_cookie_params
+
+    def __call__(self, r: PreparedRequest) -> PreparedRequest:
+        if self.__query_params:
+            r.prepare_url(r.url, self.__query_params)
+        r.headers.pop("Cookie", None)
+        new_cookie = create_cookie(  # type: ignore
+            name=self.__cookie_name,
+            value=self.__cookie_provider(),
+            **self.__extra_cookie_params
+        )
+        r._cookies.set_cookie(new_cookie)  # type: ignore
+        r.prepare_cookies(r._cookies)  # type: ignore
+        return r
+
+
+class CookieAuthScheme(AuthScheme):
+    __cookie_name: str
+    __cookie_provider: PyLegendCallable[[], str]
+    __query_params: PyLegendOptional[PyLegendDict[str, str]]
+
+    def __init__(  # type: ignore
+            self,
+            cookie_name: str,
+            cookie_provider: PyLegendCallable[[], str],
+            query_params: PyLegendOptional[PyLegendDict[str, str]] = None,
+            **extra_cookie_params
+    ) -> None:
+        self.__cookie_name = cookie_name
+        self.__cookie_provider = cookie_provider
+        self.__query_params = query_params
+        self.__extra_cookie_params = extra_cookie_params
+
+    def get_auth_base(self) -> PyLegendOptional[AuthBase]:
+        return CookieAuth(self.__cookie_name, self.__cookie_provider, self.__query_params, **self.__extra_cookie_params)

pylegend/core/request/legend_client.py

@@ -77,6 +77,38 @@ class LegendClient(ServiceClient):
         ).iter_content(chunk_size=chunk_size)
         return ResponseReader(iter_content)
 
+    def parse_model(
+            self,
+            model_code: str,
+            return_source_information: bool = False
+    ) -> str:
+        response = super()._execute_service(
+            method=RequestMethod.POST,
+            path="pure/v1/grammar/grammarToJson/model",
+            data=model_code,
+            headers={"Content-Type": "text/plain"},
+            query_params=[("returnSourceInformation", "true" if return_source_information else "false")]
+        )
+        return response.text
+
+    def compile_model(
+            self,
+            model_json: str
+    ) -> None:
+        super()._execute_service(
+            method=RequestMethod.POST,
+            path="pure/v1/compilation/compile",
+            data=model_json,
+            headers={"Content-Type": "application/json"}
+        )
+
+    def parse_and_compile_model(
+            self,
+            model_code: str
+    ) -> None:
+        parse_response = self.parse_model(model_code)
+        self.compile_model(parse_response)
+
     def __eq__(self, other: 'object') -> bool:
         if self is other:
             return True

pylegend/core/sql/metamodel_extension.py

@@ -19,6 +19,7 @@ from pylegend._typing import (
 )
 from pylegend.core.sql.metamodel import (
     Expression,
+    Window,
 )
 
 __all__: PyLegendSequence[str] = [
@@ -78,6 +79,7 @@ __all__: PyLegendSequence[str] = [
     "MinuteExpression",
     "SecondExpression",
     "EpochExpression",
+    "WindowExpression",
 ]
 
 
@@ -717,3 +719,17 @@ class EpochExpression(Expression):
     ) -> None:
         super().__init__(_type="epochExpression")
         self.value = value
+
+
+class WindowExpression(Expression):
+    nested: "Expression"
+    window: "Window"
+
+    def __init__(
+        self,
+        nested: "Expression",
+        window: "Window",
+    ) -> None:
+        super().__init__(_type="windowExpression")
+        self.nested = nested
+        self.window = window

pylegend/core/tds/abstract/__init__.py

@@ -0,0 +1,13 @@
+# 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.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

pylegend/core/tds/abstract/frames/__init__.py

@@ -0,0 +1,13 @@
+# 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.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.