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

pylegend/core/tds/legacy_api/frames/legacy_api_applied_function_tds_frame.py

@@ -0,0 +1,37 @@
+# Copyright 2023 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.
+
+from abc import ABCMeta, abstractmethod
+from pylegend._typing import (
+    PyLegendSequence,
+)
+from pylegend.core.tds.abstract.frames.applied_function_tds_frame import AppliedFunction, AppliedFunctionTdsFrame
+from pylegend.core.tds.legacy_api.frames.legacy_api_base_tds_frame import LegacyApiBaseTdsFrame
+
+
+__all__: PyLegendSequence[str] = [
+    "LegacyApiAppliedFunctionTdsFrame",
+    "LegacyApiAppliedFunction",
+]
+
+
+class LegacyApiAppliedFunction(AppliedFunction, metaclass=ABCMeta):
+    @abstractmethod
+    def tds_frame_parameters(self) -> PyLegendSequence["LegacyApiBaseTdsFrame"]:
+        pass  # pragma: no cover
+
+
+class LegacyApiAppliedFunctionTdsFrame(LegacyApiBaseTdsFrame, AppliedFunctionTdsFrame):
+    def __init__(self, applied_function: LegacyApiAppliedFunction):
+        AppliedFunctionTdsFrame.__init__(self, applied_function)

pylegend/core/tds/legacy_api/frames/legacy_api_base_tds_frame.py

@@ -0,0 +1,204 @@
+# Copyright 2023 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.
+
+from abc import ABCMeta
+
+from pylegend._typing import (
+    PyLegendSequence,
+    PyLegendTypeVar,
+    PyLegendList,
+    PyLegendOptional,
+    PyLegendCallable,
+    PyLegendUnion,
+)
+from pylegend.core.language import (
+    LegacyApiTdsRow,
+    PyLegendBoolean,
+    PyLegendPrimitiveOrPythonPrimitive,
+    LegacyApiAggregateSpecification,
+)
+from pylegend.core.tds.abstract.frames.base_tds_frame import BaseTdsFrame
+from pylegend.core.tds.legacy_api.frames.legacy_api_tds_frame import LegacyApiTdsFrame
+from pylegend.core.tds.tds_column import TdsColumn
+
+__all__: PyLegendSequence[str] = [
+    "LegacyApiBaseTdsFrame"
+]
+
+R = PyLegendTypeVar('R')
+
+
+class LegacyApiBaseTdsFrame(LegacyApiTdsFrame, BaseTdsFrame, metaclass=ABCMeta):
+
+    def __init__(self, columns: PyLegendSequence[TdsColumn]) -> None:
+        BaseTdsFrame.__init__(self, columns=columns)
+
+    def head(self, row_count: int = 5) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_head_function import (
+            LegacyApiHeadFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(LegacyApiHeadFunction(self, row_count))
+
+    def take(self, row_count: int = 5) -> "LegacyApiTdsFrame":
+        return self.head(row_count=row_count)
+
+    def limit(self, row_count: int = 5) -> "LegacyApiTdsFrame":
+        return self.head(row_count=row_count)
+
+    def drop(self, row_count: int = 5) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_drop_function import (
+            LegacyApiDropFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(LegacyApiDropFunction(self, row_count))
+
+    def slice(self, start_row: int, end_row_exclusive: int) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_slice_function import (
+            LegacyApiSliceFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(LegacyApiSliceFunction(self, start_row, end_row_exclusive))
+
+    def distinct(self) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_distinct_function import (
+            LegacyApiDistinctFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(LegacyApiDistinctFunction(self))
+
+    def restrict(self, column_name_list: PyLegendList[str]) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_restrict_function import (
+            LegacyApiRestrictFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(LegacyApiRestrictFunction(self, column_name_list))
+
+    def sort(
+            self,
+            column_name_list: PyLegendList[str],
+            direction_list: PyLegendOptional[PyLegendList[str]] = None
+    ) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_sort_function import (
+            LegacyApiSortFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(LegacyApiSortFunction(self, column_name_list, direction_list))
+
+    def concatenate(self, other: "LegacyApiTdsFrame") -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_concatenate_function import (
+            LegacyApiConcatenateFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(LegacyApiConcatenateFunction(self, other))
+
+    def rename_columns(
+            self,
+            column_names: PyLegendList[str],
+            renamed_column_names: PyLegendList[str]
+    ) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_rename_columns_function import (
+            LegacyApiRenameColumnsFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(LegacyApiRenameColumnsFunction(self, column_names, renamed_column_names))
+
+    def filter(
+            self,
+            filter_function: PyLegendCallable[[LegacyApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]]
+    ) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_filter_function import (
+            LegacyApiFilterFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(LegacyApiFilterFunction(self, filter_function))
+
+    def extend(
+            self,
+            functions_list: PyLegendList[PyLegendCallable[[LegacyApiTdsRow], PyLegendPrimitiveOrPythonPrimitive]],
+            column_names_list: PyLegendList[str]
+    ) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_extend_function import (
+            LegacyApiExtendFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(LegacyApiExtendFunction(self, functions_list, column_names_list))
+
+    def join(
+            self,
+            other: "LegacyApiTdsFrame",
+            join_condition: PyLegendCallable[[LegacyApiTdsRow, LegacyApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]],
+            join_type: str = 'LEFT_OUTER'
+    ) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_join_function import (
+            LegacyApiJoinFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(
+            LegacyApiJoinFunction(self, other, join_condition, join_type)
+        )
+
+    def join_by_columns(
+            self,
+            other: "LegacyApiTdsFrame",
+            self_columns: PyLegendList[str],
+            other_columns: PyLegendList[str],
+            join_type: str = 'LEFT_OUTER'
+    ) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_join_by_columns_function import (
+            LegacyApiJoinByColumnsFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(
+            LegacyApiJoinByColumnsFunction(self, other, self_columns, other_columns, join_type)
+        )
+
+    def group_by(
+            self,
+            grouping_columns: PyLegendList[str],
+            aggregations: PyLegendList[LegacyApiAggregateSpecification],
+    ) -> "LegacyApiTdsFrame":
+        from pylegend.core.tds.legacy_api.frames.legacy_api_applied_function_tds_frame import (
+            LegacyApiAppliedFunctionTdsFrame
+        )
+        from pylegend.core.tds.legacy_api.frames.functions.legacy_api_group_by_function import (
+            LegacyApiGroupByFunction
+        )
+        return LegacyApiAppliedFunctionTdsFrame(
+            LegacyApiGroupByFunction(self, grouping_columns, aggregations)
+        )

pylegend/core/tds/legacy_api/frames/legacy_api_input_tds_frame.py

@@ -0,0 +1,51 @@
+# Copyright 2023 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.
+
+from abc import ABCMeta
+from pylegend._typing import (
+    PyLegendSequence,
+)
+from pylegend.core.tds.abstract.frames.input_tds_frame import (
+    InputTdsFrame,
+    ExecutableInputTdsFrame,
+    NonExecutableInputTdsFrame,
+)
+from pylegend.core.tds.tds_column import TdsColumn
+from pylegend.core.tds.legacy_api.frames.legacy_api_base_tds_frame import LegacyApiBaseTdsFrame
+from pylegend.core.request.legend_client import LegendClient
+
+
+__all__: PyLegendSequence[str] = [
+    "LegacyApiExecutableInputTdsFrame",
+    "LegacyApiNonExecutableInputTdsFrame",
+    "LegacyApiInputTdsFrame"
+]
+
+
+class LegacyApiInputTdsFrame(LegacyApiBaseTdsFrame, InputTdsFrame, metaclass=ABCMeta):
+    def __init__(self, columns: PyLegendSequence[TdsColumn]) -> None:
+        LegacyApiBaseTdsFrame.__init__(self, columns=columns)
+        InputTdsFrame.__init__(self, columns=columns)
+
+
+class LegacyApiExecutableInputTdsFrame(LegacyApiInputTdsFrame, ExecutableInputTdsFrame, metaclass=ABCMeta):
+    def __init__(self, legend_client: LegendClient, columns: PyLegendSequence[TdsColumn]) -> None:
+        LegacyApiInputTdsFrame.__init__(self, columns=columns)
+        ExecutableInputTdsFrame.__init__(self, legend_client=legend_client, columns=columns)
+
+
+class LegacyApiNonExecutableInputTdsFrame(LegacyApiInputTdsFrame, NonExecutableInputTdsFrame, metaclass=ABCMeta):
+    def __init__(self, columns: PyLegendSequence[TdsColumn]) -> None:
+        LegacyApiInputTdsFrame.__init__(self, columns=columns)
+        NonExecutableInputTdsFrame.__init__(self, columns=columns)

pylegend/core/tds/{legend_api/frames/legend_api_tds_frame.py → legacy_api/frames/legacy_api_tds_frame.py}

@@ -24,45 +24,45 @@ from pylegend._typing import (
     PyLegendUnion,
 )
 from pylegend.core.language import (
-    TdsRow,
+    LegacyApiTdsRow,
     PyLegendBoolean,
     PyLegendPrimitiveOrPythonPrimitive,
-    AggregateSpecification,
+    LegacyApiAggregateSpecification,
 )
 
 __all__: PyLegendSequence[str] = [
-    "LegendApiTdsFrame"
+    "LegacyApiTdsFrame"
 ]
 
 
-class LegendApiTdsFrame(PyLegendTdsFrame):
+class LegacyApiTdsFrame(PyLegendTdsFrame):
 
     @abstractmethod
-    def head(self, count: int = 5) -> "LegendApiTdsFrame":
+    def head(self, count: int = 5) -> "LegacyApiTdsFrame":
         pass  # pragma: no cover
 
     @abstractmethod
-    def take(self, count: int = 5) -> "LegendApiTdsFrame":
+    def take(self, count: int = 5) -> "LegacyApiTdsFrame":
         pass  # pragma: no cover
 
     @abstractmethod
-    def limit(self, count: int = 5) -> "LegendApiTdsFrame":
+    def limit(self, count: int = 5) -> "LegacyApiTdsFrame":
         pass  # pragma: no cover
 
     @abstractmethod
-    def drop(self, count: int = 5) -> "LegendApiTdsFrame":
+    def drop(self, count: int = 5) -> "LegacyApiTdsFrame":
         pass  # pragma: no cover
 
     @abstractmethod
-    def slice(self, start_row: int, end_row_exclusive: int) -> "LegendApiTdsFrame":
+    def slice(self, start_row: int, end_row_exclusive: int) -> "LegacyApiTdsFrame":
         pass  # pragma: no cover
 
     @abstractmethod
-    def distinct(self) -> "LegendApiTdsFrame":
+    def distinct(self) -> "LegacyApiTdsFrame":
         pass  # pragma: no cover
 
     @abstractmethod
-    def restrict(self, column_name_list: PyLegendList[str]) -> "LegendApiTdsFrame":
+    def restrict(self, column_name_list: PyLegendList[str]) -> "LegacyApiTdsFrame":
         pass  # pragma: no cover
 
     @abstractmethod
@@ -70,11 +70,11 @@ class LegendApiTdsFrame(PyLegendTdsFrame):
             self,
             column_name_list: PyLegendList[str],
             direction_list: PyLegendOptional[PyLegendList[str]] = None
-    ) -> "LegendApiTdsFrame":
+    ) -> "LegacyApiTdsFrame":
         pass  # pragma: no cover
 
     @abstractmethod
-    def concatenate(self, other: "LegendApiTdsFrame") -> "LegendApiTdsFrame":
+    def concatenate(self, other: "LegacyApiTdsFrame") -> "LegacyApiTdsFrame":
         pass  # pragma: no cover
 
     @abstractmethod
@@ -82,55 +82,55 @@ class LegendApiTdsFrame(PyLegendTdsFrame):
             self,
             column_names: PyLegendList[str],
             renamed_column_names: PyLegendList[str]
-    ) -> "LegendApiTdsFrame":
+    ) -> "LegacyApiTdsFrame":
         pass  # pragma: no cover
 
     @abstractmethod
     def filter(
             self,
-            filter_function: PyLegendCallable[[TdsRow], PyLegendUnion[bool, PyLegendBoolean]]
-    ) -> "LegendApiTdsFrame":
+            filter_function: PyLegendCallable[[LegacyApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]]
+    ) -> "LegacyApiTdsFrame":
         pass  # pragma: no cover
 
     @abstractmethod
     def extend(
             self,
-            functions_list: PyLegendList[PyLegendCallable[[TdsRow], PyLegendPrimitiveOrPythonPrimitive]],
+            functions_list: PyLegendList[PyLegendCallable[[LegacyApiTdsRow], PyLegendPrimitiveOrPythonPrimitive]],
             column_names_list: PyLegendList[str]
-    ) -> "LegendApiTdsFrame":
+    ) -> "LegacyApiTdsFrame":
         pass  # pragma: no cover
 
     @abstractmethod
     def join(
             self,
-            other: "LegendApiTdsFrame",
-            join_condition: PyLegendCallable[[TdsRow, TdsRow], PyLegendUnion[bool, PyLegendBoolean]],
+            other: "LegacyApiTdsFrame",
+            join_condition: PyLegendCallable[[LegacyApiTdsRow, LegacyApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]],
             join_type: str = 'LEFT_OUTER'
-    ) -> "LegendApiTdsFrame":
+    ) -> "LegacyApiTdsFrame":
         pass  # pragma: no cover
 
     @abstractmethod
     def join_by_columns(
             self,
-            other: "LegendApiTdsFrame",
+            other: "LegacyApiTdsFrame",
             self_columns: PyLegendList[str],
             other_columns: PyLegendList[str],
             join_type: str = 'LEFT_OUTER'
-    ) -> "LegendApiTdsFrame":
+    ) -> "LegacyApiTdsFrame":
         pass  # pragma: no cover
 
     def join_by_function(
             self,
-            other: "LegendApiTdsFrame",
-            join_condition: PyLegendCallable[[TdsRow, TdsRow], PyLegendUnion[bool, PyLegendBoolean]],
+            other: "LegacyApiTdsFrame",
+            join_condition: PyLegendCallable[[LegacyApiTdsRow, LegacyApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]],
             join_type: str = 'LEFT_OUTER'
-    ) -> "LegendApiTdsFrame":
+    ) -> "LegacyApiTdsFrame":
         return self.join(other, join_condition, join_type)
 
     @abstractmethod
     def group_by(
             self,
             grouping_columns: PyLegendList[str],
-            aggregations: PyLegendList[AggregateSpecification],
-    ) -> "LegendApiTdsFrame":
+            aggregations: PyLegendList[LegacyApiAggregateSpecification],
+    ) -> "LegacyApiTdsFrame":
         pass  # pragma: no cover

pylegend/core/tds/legendql_api/__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/legendql_api/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.

pylegend/core/tds/legendql_api/frames/functions/__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/legendql_api/frames/functions/legendql_api_asofjoin_function.py

@@ -0,0 +1,156 @@
+# 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.
+
+from pylegend._typing import (
+    PyLegendList,
+    PyLegendSequence,
+    PyLegendUnion,
+    PyLegendCallable,
+    PyLegendOptional,
+)
+from pylegend.core.language import (
+    PyLegendBoolean,
+    PyLegendPrimitive,
+    convert_literal_to_literal_expression,
+)
+from pylegend.core.language.legendql_api.legendql_api_tds_row import LegendQLApiTdsRow
+from pylegend.core.language.shared.helpers import generate_pure_lambda
+from pylegend.core.sql.metamodel import (
+    QuerySpecification,
+)
+from pylegend.core.tds.legendql_api.frames.legendql_api_applied_function_tds_frame import LegendQLApiAppliedFunction
+from pylegend.core.tds.legendql_api.frames.legendql_api_base_tds_frame import LegendQLApiBaseTdsFrame
+from pylegend.core.tds.legendql_api.frames.legendql_api_tds_frame import LegendQLApiTdsFrame
+from pylegend.core.tds.tds_column import TdsColumn
+from pylegend.core.tds.tds_frame import FrameToPureConfig
+from pylegend.core.tds.tds_frame import FrameToSqlConfig
+
+__all__: PyLegendSequence[str] = [
+    "LegendQLApiAsOfJoinFunction"
+]
+
+
+class LegendQLApiAsOfJoinFunction(LegendQLApiAppliedFunction):
+    __base_frame: LegendQLApiBaseTdsFrame
+    __other_frame: LegendQLApiBaseTdsFrame
+    __match_function: PyLegendCallable[[LegendQLApiTdsRow, LegendQLApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]]
+    __join_condition: PyLegendOptional[
+        PyLegendCallable[[LegendQLApiTdsRow, LegendQLApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]]
+    ]
+
+    @classmethod
+    def name(cls) -> str:
+        return "asOfJoin"
+
+    def __init__(
+            self,
+            base_frame: LegendQLApiBaseTdsFrame,
+            other_frame: LegendQLApiTdsFrame,
+            match_function: PyLegendCallable[[LegendQLApiTdsRow, LegendQLApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]],
+            join_condition: PyLegendOptional[
+                PyLegendCallable[[LegendQLApiTdsRow, LegendQLApiTdsRow], PyLegendUnion[bool, PyLegendBoolean]]
+            ] = None
+    ) -> None:
+        self.__base_frame = base_frame
+        if not isinstance(other_frame, LegendQLApiBaseTdsFrame):
+            raise ValueError("Expected LegendQLApiBaseTdsFrame")  # pragma: no cover
+        self.__other_frame = other_frame
+        self.__match_function = match_function
+        self.__join_condition = join_condition
+
+    def to_sql(self, config: FrameToSqlConfig) -> QuerySpecification:
+        raise RuntimeError("AsOfJoin SQL translation not supported yet")
+
+    def to_pure(self, config: FrameToPureConfig) -> str:
+        left_row = LegendQLApiTdsRow.from_tds_frame("l", self.__base_frame)
+        right_row = LegendQLApiTdsRow.from_tds_frame("r", self.__other_frame)
+        match_expr = self.__match_function(left_row, right_row)
+        match_string = (match_expr.to_pure_expression(config.push_indent(2))
+                        if isinstance(match_expr, PyLegendPrimitive) else
+                        convert_literal_to_literal_expression(match_expr).to_pure_expression(config.push_indent(2)))
+        if self.__join_condition is not None:
+            join_expr = self.__join_condition(left_row, right_row)
+            join_string = (join_expr.to_pure_expression(config.push_indent(2))
+                           if isinstance(join_expr, PyLegendPrimitive) else
+                           convert_literal_to_literal_expression(join_expr).to_pure_expression(config.push_indent(2)))
+            join_arg = (
+                f",{config.separator(2, True)}"
+                f"{generate_pure_lambda('l, r', join_string)}{config.separator(1)}"
+            )
+        else:
+            join_arg = f"{config.separator(1)}"
+
+        return (f"{self.__base_frame.to_pure(config)}{config.separator(1)}" +
+                f"->asOfJoin({config.separator(2)}"
+                f"{self.__other_frame.to_pure(config.push_indent(2))},{config.separator(2, True)}"
+                f"{generate_pure_lambda('l, r', match_string)}"
+                f"{join_arg}"
+                f")")
+
+    def base_frame(self) -> LegendQLApiBaseTdsFrame:
+        return self.__base_frame
+
+    def tds_frame_parameters(self) -> PyLegendList["LegendQLApiBaseTdsFrame"]:
+        return [self.__other_frame]
+
+    def calculate_columns(self) -> PyLegendSequence["TdsColumn"]:
+        return (
+            [c.copy() for c in self.__base_frame.columns()] +
+            [c.copy() for c in self.__other_frame.columns()]
+        )
+
+    def validate(self) -> bool:
+        copy = self.__match_function  # For MyPy
+        if not isinstance(copy, type(lambda x: 0)) or (copy.__code__.co_argcount != 2):
+            raise TypeError("AsOfJoin match function should be a lambda which takes two arguments (TDSRow, TDSRow)")
+
+        left_row = LegendQLApiTdsRow.from_tds_frame("left", self.__base_frame)
+        right_row = LegendQLApiTdsRow.from_tds_frame("right", self.__other_frame)
+
+        try:
+            result = self.__match_function(left_row, right_row)
+        except Exception as e:
+            raise RuntimeError(
+                "AsOfJoin match function incompatible. Error occurred while evaluating. Message: " + str(e)
+            ) from e
+
+        if not isinstance(result, (bool, PyLegendBoolean)):
+            raise RuntimeError("AsOfJoin match function incompatible. Returns non boolean - " + str(type(result)))
+
+        if self.__join_condition is not None:
+            copy = self.__join_condition  # For MyPy
+            if not isinstance(copy, type(lambda x: 0)) or (copy.__code__.co_argcount != 2):
+                raise TypeError("AsOfJoin join function should be a lambda which takes two arguments (TDSRow, TDSRow)")
+
+            try:
+                result = self.__join_condition(left_row, right_row)
+            except Exception as e:
+                raise RuntimeError(
+                    "AsOfJoin join function incompatible. Error occurred while evaluating. Message: " + str(e)
+                ) from e
+
+            if not isinstance(result, (bool, PyLegendBoolean)):
+                raise RuntimeError("AsOfJoin join function incompatible. Returns non boolean - " + str(type(result)))
+
+        left_cols = [c.get_name() for c in self.__base_frame.columns()]
+        right_cols = [c.get_name() for c in self.__other_frame.columns()]
+
+        final_cols = left_cols + right_cols
+        if len(final_cols) != len(set(final_cols)):
+            raise ValueError(
+                "Found duplicate columns in joined frames. Use rename function to ensure there are no duplicate columns "
+                f"in joined frames. Columns - Left Frame: {left_cols}, Right Frame: {right_cols}"
+            )
+
+        return True