pylegend 0.1.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

pylegend/__init__.py

@@ -15,10 +15,40 @@
 from pylegend._typing import (
     PyLegendSequence,
 )
+from pylegend.legend_api_tds_client import (
+    LegendApiTdsClient,
+    legend_api_tds_client,
+)
+from pylegend.core.request import (
+    LegendClient,
+    AuthScheme,
+    LocalhostEmptyAuthScheme,
+    ResponseReader,
+)
+from pylegend.core.project_cooridnates import (
+    VersionedProjectCoordinates,
+    PersonalWorkspaceProjectCoordinates,
+    GroupWorkspaceProjectCoordinates,
+)
+from pylegend.core.language import agg
 
 
 __all__: PyLegendSequence[str] = [
-    "__version__"
+    "__version__",
+
+    "LegendApiTdsClient",
+    "legend_api_tds_client",
+
+    "LegendClient",
+    "AuthScheme",
+    "LocalhostEmptyAuthScheme",
+    "ResponseReader",
+
+    "VersionedProjectCoordinates",
+    "PersonalWorkspaceProjectCoordinates",
+    "GroupWorkspaceProjectCoordinates",
+
+    "agg",
 ]
 
 

pylegend/core/language/__init__.py

@@ -58,7 +58,7 @@ from pylegend.core.language.column_expressions import (
     PyLegendStrictDateColumnExpression,
 )
 from pylegend.core.language.tds_row import TdsRow
-from pylegend.core.language.aggregate_specification import AggregateSpecification
+from pylegend.core.language.aggregate_specification import AggregateSpecification, agg
 from pylegend.core.language.primitive_collection import (
     PyLegendPrimitiveCollection,
     PyLegendIntegerCollection,
@@ -117,6 +117,7 @@ __all__: PyLegendSequence[str] = [
 
     "TdsRow",
     "AggregateSpecification",
+    "agg",
 
     "PyLegendPrimitiveCollection",
     "PyLegendIntegerCollection",

pylegend/core/language/aggregate_specification.py

@@ -25,6 +25,7 @@ from pylegend.core.language import (
 
 __all__: PyLegendSequence[str] = [
     "AggregateSpecification",
+    "agg",
 ]
 
 
@@ -51,3 +52,11 @@ class AggregateSpecification:
 
     def get_aggregate_fn(self) -> PyLegendCallable[[PyLegendPrimitiveCollection], PyLegendPrimitive]:
         return self.__aggregate_fn
+
+
+def agg(
+    map_fn: PyLegendCallable[[TdsRow], PyLegendPrimitiveOrPythonPrimitive],
+    aggregate_fn: PyLegendCallable[[PyLegendPrimitiveCollection], PyLegendPrimitive],
+    name: str
+) -> AggregateSpecification:
+    return AggregateSpecification(map_fn=map_fn, aggregate_fn=aggregate_fn, name=name)

pylegend/core/project_cooridnates.py

@@ -0,0 +1,125 @@
+# 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.
+
+import abc
+from abc import ABCMeta
+from pylegend._typing import (
+    PyLegendSequence,
+    PyLegendList,
+)
+from pylegend.core.sql.metamodel import (
+    NamedArgumentExpression,
+    StringLiteral,
+)
+
+__all__: PyLegendSequence[str] = [
+    "ProjectCoordinates",
+    "VersionedProjectCoordinates",
+    "PersonalWorkspaceProjectCoordinates",
+    "GroupWorkspaceProjectCoordinates",
+]
+
+
+class ProjectCoordinates(metaclass=ABCMeta):
+
+    @abc.abstractmethod
+    def sql_params(self) -> PyLegendList[NamedArgumentExpression]:
+        pass
+
+
+class VersionedProjectCoordinates(ProjectCoordinates):
+    __group_id: str
+    __artifact_id: str
+    __version: str
+
+    def __init__(self, group_id: str, artifact_id: str, version: str) -> None:
+        self.__group_id = group_id
+        self.__artifact_id = artifact_id
+        self.__version = version
+
+    def get_group_id(self) -> str:
+        return self.__group_id
+
+    def get_artifact_id(self) -> str:
+        return self.__artifact_id
+
+    def get_version(self) -> str:
+        return self.__version
+
+    def sql_params(self) -> PyLegendList[NamedArgumentExpression]:
+        return [
+            NamedArgumentExpression(
+                name="coordinates",
+                expression=StringLiteral(
+                    value=f"{self.__group_id}:{self.__artifact_id}:{self.__version}",
+                    quoted=False
+                )
+            )
+        ]
+
+
+class WorkspaceProjectCoordinates(ProjectCoordinates, metaclass=ABCMeta):
+    __project_id: str
+
+    def __init__(self, project_id: str) -> None:
+        self.__project_id = project_id
+
+    def get_project_id(self) -> str:
+        return self.__project_id
+
+
+class PersonalWorkspaceProjectCoordinates(WorkspaceProjectCoordinates):
+    __workspace: str
+
+    def __init__(self, project_id: str, workspace: str) -> None:
+        super().__init__(project_id)
+        self.__workspace = workspace
+
+    def get_workspace(self) -> str:
+        return self.__workspace
+
+    def sql_params(self) -> PyLegendList[NamedArgumentExpression]:
+        return [
+            NamedArgumentExpression(
+                name="project",
+                expression=StringLiteral(value=self.get_project_id(), quoted=False)
+            ),
+            NamedArgumentExpression(
+                name="workspace",
+                expression=StringLiteral(value=self.__workspace, quoted=False)
+            )
+        ]
+
+
+class GroupWorkspaceProjectCoordinates(WorkspaceProjectCoordinates):
+    __group_workspace: str
+
+    def __init__(self, project_id: str, group_workspace: str) -> None:
+        super().__init__(project_id)
+        self.__group_workspace = group_workspace
+
+    def get_group_workspace(self) -> str:
+        return self.__group_workspace
+
+    def sql_params(self) -> PyLegendList[NamedArgumentExpression]:
+        return [
+            NamedArgumentExpression(
+                name="project",
+                expression=StringLiteral(value=self.get_project_id(), quoted=False)
+            ),
+            NamedArgumentExpression(
+                name="groupWorkspace",
+                expression=StringLiteral(value=self.__group_workspace, quoted=False)
+            )
+        ]

pylegend/core/request/__init__.py

@@ -11,3 +11,19 @@
 # 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 (
+    PyLegendSequence,
+)
+from pylegend.core.request.legend_client import LegendClient
+from pylegend.core.request.auth import AuthScheme, LocalhostEmptyAuthScheme
+from pylegend.core.request.response_reader import ResponseReader
+
+__all__: PyLegendSequence[str] = [
+    "LegendClient",
+
+    "AuthScheme",
+    "LocalhostEmptyAuthScheme",
+
+    "ResponseReader"
+]

pylegend/core/request/auth.py

@@ -0,0 +1,61 @@
+# 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 requests import PreparedRequest
+
+from pylegend._typing import (
+    PyLegendSequence,
+    PyLegendOptional,
+)
+from requests.auth import AuthBase
+
+__all__: PyLegendSequence[str] = [
+    "AuthScheme",
+    "LocalhostEmptyAuthScheme",
+    "BearerAuthScheme"
+]
+
+
+class AuthScheme(metaclass=ABCMeta):
+
+    @abstractmethod
+    def get_auth_base(self) -> PyLegendOptional[AuthBase]:
+        pass
+
+
+class LocalhostEmptyAuthScheme(AuthScheme):
+
+    def get_auth_base(self) -> PyLegendOptional[AuthBase]:
+        return None
+
+
+class BearerAuth(AuthBase):
+    def __init__(self, headerName: str, token: str) -> None:
+        self.headerName = headerName
+        self.token = token
+
+    def __call__(self, r: PreparedRequest) -> PreparedRequest:
+        r.headers[self.headerName] = self.token
+        return r
+
+
+class BearerAuthScheme(AuthScheme):
+    def __init__(self, headerName: str, token: str) -> None:
+        self.headerName = headerName
+        self.token = token
+
+    def get_auth_base(self) -> PyLegendOptional[AuthBase]:
+        return BearerAuth(self.headerName, self.token)

pylegend/core/request/legend_client.py

@@ -17,6 +17,7 @@ from pylegend.core.request.service_client import (
     RequestMethod
 )
 from pylegend.core.request.response_reader import ResponseReader
+from pylegend.core.request.auth import AuthScheme, LocalhostEmptyAuthScheme
 from pylegend._typing import (
     PyLegendSequence,
     PyLegendOptional,
@@ -24,15 +25,29 @@ from pylegend._typing import (
 from pylegend.core.tds.tds_column import TdsColumn, tds_columns_from_json
 
 
+__all__: PyLegendSequence[str] = [
+    "LegendClient",
+]
+
+
 class LegendClient(ServiceClient):
     def __init__(
             self,
             host: str,
             port: int,
             secure_http: bool = True,
+            path_prefix: PyLegendOptional[str] = "/api",
+            auth_scheme: AuthScheme = LocalhostEmptyAuthScheme(),
             retry_count: int = 2
     ) -> None:
-        super().__init__(host=host, port=port, secure_http=secure_http, retry_count=retry_count)
+        super().__init__(
+            host=host,
+            port=port,
+            secure_http=secure_http,
+            path_prefix=path_prefix,
+            auth_scheme=auth_scheme,
+            retry_count=retry_count
+        )
 
     def get_sql_string_schema(
             self,
@@ -40,7 +55,7 @@ class LegendClient(ServiceClient):
     ) -> PyLegendSequence[TdsColumn]:
         response = super()._execute_service(
             method=RequestMethod.POST,
-            path="api/sql/v1/execution/getSchemaFromQueryString",
+            path="sql/v1/execution/getSchemaFromQueryString",
             data=sql,
             headers={"Content-Type": "text/plain"},
             stream=False
@@ -55,7 +70,7 @@ class LegendClient(ServiceClient):
     ) -> ResponseReader:
         iter_content = super()._execute_service(
             method=RequestMethod.POST,
-            path="api/sql/v1/execution/executeQueryString",
+            path="sql/v1/execution/executeQueryString",
             data=sql,
             headers={"Content-Type": "text/plain"},
             stream=True

pylegend/core/request/service_client.py

@@ -17,6 +17,7 @@ from enum import Enum
 
 import requests
 from requests.adapters import HTTPAdapter, Retry
+from pylegend.core.request.auth import AuthScheme
 from pylegend._typing import (
     PyLegendSequence,
     PyLegendOptional,
@@ -39,9 +40,19 @@ class RequestMethod(Enum):
 
 class ServiceClient(metaclass=ABCMeta):
 
-    def __init__(self, host: str, port: int, secure_http: bool, retry_count: int) -> None:
+    def __init__(
+            self,
+            host: str,
+            port: int,
+            secure_http: bool,
+            path_prefix: PyLegendOptional[str],
+            auth_scheme: AuthScheme,
+            retry_count: int
+    ) -> None:
         self.__host = host
         self.__port = port
+        self.__auth_scheme = auth_scheme
+        self.__path_prefix = path_prefix
         self.__secure_http = secure_http
         if retry_count < 1:
             raise ValueError("Retry count should be a number greater than 1. Got " + str(retry_count))
@@ -64,14 +75,17 @@ class ServiceClient(metaclass=ABCMeta):
     ) -> requests.Response:
 
         scheme = "https" if self.__secure_http else "http"
-        url = f"{scheme}://{self.__host}:{self.__port}/{path}"
+        prefix = (self.__path_prefix if self.__path_prefix.startswith("/") else f"/{self.__path_prefix}") \
+            if self.__path_prefix is not None else ""
+        url = f"{scheme}://{self.__host}:{self.__port}{prefix}/{path}"
 
         request = requests.Request(
             method=method.name,
             url=url,
             headers=headers,
             data=data,
-            params=query_params
+            params=query_params,
+            auth=self.__auth_scheme.get_auth_base(),
         )
 
         session = requests.Session()

pylegend/core/tds/tds_column.py

@@ -150,7 +150,7 @@ def tds_columns_from_json(s: str) -> PyLegendSequence[TdsColumn]:
 
         result_columns: PyLegendList[TdsColumn] = []
         for col in columns:
-            if col["__TYPE"] == "meta::external::query::sql::PrimitiveValueSchemaColumn":
+            if col["_type"] == "primitiveSchemaColumn":
                 result_columns.append(PrimitiveTdsColumn(col["name"], PrimitiveType[col["type"]]))
             else:
                 result_columns.append(

pylegend/extensions/tds/abstract/__init__.py

@@ -0,0 +1,13 @@
+# 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.

pylegend/extensions/tds/abstract/legend_function_input_frame.py

@@ -0,0 +1,108 @@
+# 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 (
+    PyLegendList,
+    PyLegendSequence,
+)
+from pylegend.core.tds.tds_frame import (
+    PyLegendTdsFrame,
+    FrameToSqlConfig,
+)
+from pylegend.core.project_cooridnates import ProjectCoordinates
+from pylegend.core.sql.metamodel import (
+    QuerySpecification,
+    TableFunction,
+    Select,
+    AllColumns,
+    FunctionCall,
+    QualifiedName,
+    NamedArgumentExpression,
+    StringLiteral,
+    AliasedRelation,
+    SingleColumn,
+    QualifiedNameReference,
+    Expression,
+)
+
+__all__: PyLegendSequence[str] = [
+    "LegendFunctionInputFrameAbstract",
+]
+
+
+class LegendFunctionInputFrameAbstract(PyLegendTdsFrame, metaclass=ABCMeta):
+    __path: str
+    __project_coordinates: ProjectCoordinates
+    __initialized: bool = False
+
+    def __init__(
+            self,
+            path: str,
+            project_coordinates: ProjectCoordinates,
+    ) -> None:
+        self.__path = path
+        self.__project_coordinates = project_coordinates
+
+    def to_sql_query_object(self, config: FrameToSqlConfig) -> QuerySpecification:
+        db_extension = config.sql_to_string_generator().get_db_extension()
+        root_alias = db_extension.quote_identifier("root")
+        args: PyLegendList[Expression] = [
+            NamedArgumentExpression(
+                name="path",
+                expression=StringLiteral(value=self.__path, quoted=False)
+            )
+        ]
+        args += self.__project_coordinates.sql_params()
+        func_call = FunctionCall(
+            name=QualifiedName(["func"]),
+            distinct=False,
+            filter_=None,
+            window=None,
+            arguments=args
+        )
+
+        return QuerySpecification(
+            select=Select(
+                selectItems=[
+                    SingleColumn(
+                        alias=db_extension.quote_identifier(x.get_name()),
+                        expression=QualifiedNameReference(
+                            name=QualifiedName(parts=[root_alias, db_extension.quote_identifier(x.get_name())])
+                        )
+                    )
+                    for x in self.columns()
+                ] if self.__initialized else [AllColumns(prefix=root_alias)],
+                distinct=False
+            ),
+            from_=[
+                AliasedRelation(
+                    relation=TableFunction(functionCall=func_call),
+                    alias=root_alias,
+                    columnNames=[x.get_name() for x in self.columns()] if self.__initialized else []
+                )
+            ],
+            where=None,
+            groupBy=[],
+            having=None,
+            orderBy=[],
+            limit=None,
+            offset=None
+        )
+
+    def get_path(self) -> str:
+        return self.__path
+
+    def set_initialized(self, val: bool) -> None:
+        self.__initialized = val

pylegend/extensions/tds/abstract/legend_service_input_frame.py

@@ -0,0 +1,108 @@
+# 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 (
+    PyLegendList,
+    PyLegendSequence,
+)
+from pylegend.core.tds.tds_frame import (
+    PyLegendTdsFrame,
+    FrameToSqlConfig,
+)
+from pylegend.core.project_cooridnates import ProjectCoordinates
+from pylegend.core.sql.metamodel import (
+    QuerySpecification,
+    TableFunction,
+    Select,
+    AllColumns,
+    FunctionCall,
+    QualifiedName,
+    NamedArgumentExpression,
+    StringLiteral,
+    AliasedRelation,
+    SingleColumn,
+    QualifiedNameReference,
+    Expression,
+)
+
+__all__: PyLegendSequence[str] = [
+    "LegendServiceInputFrameAbstract",
+]
+
+
+class LegendServiceInputFrameAbstract(PyLegendTdsFrame, metaclass=ABCMeta):
+    __pattern: str
+    __project_coordinates: ProjectCoordinates
+    __initialized: bool = False
+
+    def __init__(
+            self,
+            pattern: str,
+            project_coordinates: ProjectCoordinates,
+    ) -> None:
+        self.__pattern = pattern
+        self.__project_coordinates = project_coordinates
+
+    def to_sql_query_object(self, config: FrameToSqlConfig) -> QuerySpecification:
+        db_extension = config.sql_to_string_generator().get_db_extension()
+        root_alias = db_extension.quote_identifier("root")
+        args: PyLegendList[Expression] = [
+            NamedArgumentExpression(
+                name="pattern",
+                expression=StringLiteral(value=self.__pattern, quoted=False)
+            )
+        ]
+        args += self.__project_coordinates.sql_params()
+        func_call = FunctionCall(
+            name=QualifiedName(["service"]),
+            distinct=False,
+            filter_=None,
+            window=None,
+            arguments=args
+        )
+
+        return QuerySpecification(
+            select=Select(
+                selectItems=[
+                    SingleColumn(
+                        alias=db_extension.quote_identifier(x.get_name()),
+                        expression=QualifiedNameReference(
+                            name=QualifiedName(parts=[root_alias, db_extension.quote_identifier(x.get_name())])
+                        )
+                    )
+                    for x in self.columns()
+                ] if self.__initialized else [AllColumns(prefix=root_alias)],
+                distinct=False
+            ),
+            from_=[
+                AliasedRelation(
+                    relation=TableFunction(functionCall=func_call),
+                    alias=root_alias,
+                    columnNames=[x.get_name() for x in self.columns()] if self.__initialized else []
+                )
+            ],
+            where=None,
+            groupBy=[],
+            having=None,
+            orderBy=[],
+            limit=None,
+            offset=None
+        )
+
+    def get_pattern(self) -> str:
+        return self.__pattern
+
+    def set_initialized(self, val: bool) -> None:
+        self.__initialized = val

pylegend/extensions/tds/abstract/table_spec_input_frame.py

@@ -0,0 +1,70 @@
+# 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,
+    PyLegendList,
+)
+from pylegend.core.sql.metamodel import (
+    QualifiedName,
+    QualifiedNameReference,
+    QuerySpecification,
+    Select,
+    SingleColumn,
+    Table,
+    AliasedRelation
+)
+from pylegend.core.tds.tds_frame import PyLegendTdsFrame
+from pylegend.core.tds.tds_frame import FrameToSqlConfig
+
+__all__: PyLegendSequence[str] = [
+    "TableSpecInputFrameAbstract",
+]
+
+
+class TableSpecInputFrameAbstract(PyLegendTdsFrame, metaclass=ABCMeta):
+    table: QualifiedName
+
+    def __init__(self, table_name_parts: PyLegendList[str]) -> None:
+        self.table = QualifiedName(table_name_parts)
+
+    def to_sql_query_object(self, config: FrameToSqlConfig) -> QuerySpecification:
+        db_extension = config.sql_to_string_generator().get_db_extension()
+        root_alias = db_extension.quote_identifier("root")
+        return QuerySpecification(
+            select=Select(
+                selectItems=[
+                    SingleColumn(
+                        alias=db_extension.quote_identifier(x.get_name()),
+                        expression=QualifiedNameReference(name=QualifiedName(parts=[root_alias, x.get_name()]))
+                    )
+                    for x in self.columns()
+                ],
+                distinct=False
+            ),
+            from_=[
+                AliasedRelation(
+                    relation=Table(name=self.table),
+                    alias=root_alias,
+                    columnNames=[x.get_name() for x in self.columns()]
+                )
+            ],
+            where=None,
+            groupBy=[],
+            having=None,
+            orderBy=[],
+            limit=None,
+            offset=None
+        )

pylegend/extensions/tds/legend_api/frames/legend_api_legend_function_input_frame.py

@@ -0,0 +1,46 @@
+# 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 pylegend._typing import (
+    PyLegendSequence
+)
+from pylegend.core.tds.legend_api.frames.legend_api_input_tds_frame import LegendApiExecutableInputTdsFrame
+from pylegend.core.project_cooridnates import ProjectCoordinates
+from pylegend.core.request.legend_client import LegendClient
+from pylegend.extensions.tds.abstract.legend_function_input_frame import LegendFunctionInputFrameAbstract
+
+
+__all__: PyLegendSequence[str] = [
+    "LegendApiLegendFunctionInputFrame"
+]
+
+
+class LegendApiLegendFunctionInputFrame(LegendFunctionInputFrameAbstract, LegendApiExecutableInputTdsFrame):
+
+    def __init__(
+            self,
+            path: str,
+            project_coordinates: ProjectCoordinates,
+            legend_client: LegendClient,
+    ) -> None:
+        LegendFunctionInputFrameAbstract.__init__(self, path=path, project_coordinates=project_coordinates)
+        LegendApiExecutableInputTdsFrame.__init__(
+            self,
+            legend_client=legend_client,
+            columns=legend_client.get_sql_string_schema(self.to_sql_query())
+        )
+        LegendFunctionInputFrameAbstract.set_initialized(self, True)
+
+    def __str__(self) -> str:
+        return f"LegendApiLegendFunctionInputFrame({'.'.join(self.get_path())})"

pylegend/extensions/tds/legend_api/frames/legend_api_legend_service_input_frame.py

@@ -0,0 +1,46 @@
+# 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 pylegend._typing import (
+    PyLegendSequence
+)
+from pylegend.core.tds.legend_api.frames.legend_api_input_tds_frame import LegendApiExecutableInputTdsFrame
+from pylegend.core.project_cooridnates import ProjectCoordinates
+from pylegend.core.request.legend_client import LegendClient
+from pylegend.extensions.tds.abstract.legend_service_input_frame import LegendServiceInputFrameAbstract
+
+
+__all__: PyLegendSequence[str] = [
+    "LegendApiLegendServiceInputFrame"
+]
+
+
+class LegendApiLegendServiceInputFrame(LegendServiceInputFrameAbstract, LegendApiExecutableInputTdsFrame):
+
+    def __init__(
+            self,
+            pattern: str,
+            project_coordinates: ProjectCoordinates,
+            legend_client: LegendClient,
+    ) -> None:
+        LegendServiceInputFrameAbstract.__init__(self, pattern=pattern, project_coordinates=project_coordinates)
+        LegendApiExecutableInputTdsFrame.__init__(
+            self,
+            legend_client=legend_client,
+            columns=legend_client.get_sql_string_schema(self.to_sql_query())
+        )
+        LegendApiLegendServiceInputFrame.set_initialized(self, True)
+
+    def __str__(self) -> str:
+        return f"LegendApiLegendServiceInputFrame({'.'.join(self.get_pattern())})"

pylegend/extensions/tds/legend_api/frames/legend_api_table_spec_input_frame.py

@@ -16,18 +16,9 @@ from pylegend._typing import (
     PyLegendList,
     PyLegendSequence
 )
-from pylegend.core.sql.metamodel import (
-    QualifiedName,
-    QualifiedNameReference,
-    QuerySpecification,
-    Select,
-    SingleColumn,
-    Table,
-    AliasedRelation
-)
 from pylegend.core.tds.legend_api.frames.legend_api_input_tds_frame import LegendApiNonExecutableInputTdsFrame
 from pylegend.core.tds.tds_column import TdsColumn
-from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.extensions.tds.abstract.table_spec_input_frame import TableSpecInputFrameAbstract
 
 
 __all__: PyLegendSequence[str] = [
@@ -35,41 +26,11 @@ __all__: PyLegendSequence[str] = [
 ]
 
 
-class LegendApiTableSpecInputFrame(LegendApiNonExecutableInputTdsFrame):
-    table: QualifiedName
+class LegendApiTableSpecInputFrame(TableSpecInputFrameAbstract, LegendApiNonExecutableInputTdsFrame):
 
     def __init__(self, table_name_parts: PyLegendList[str], columns: PyLegendSequence[TdsColumn]) -> None:
-        super().__init__(columns=columns)
-        self.table = QualifiedName(table_name_parts)
-
-    def to_sql_query_object(self, config: FrameToSqlConfig) -> QuerySpecification:
-        db_extension = config.sql_to_string_generator().get_db_extension()
-        root_alias = db_extension.quote_identifier("root")
-        return QuerySpecification(
-            select=Select(
-                selectItems=[
-                    SingleColumn(
-                        alias=db_extension.quote_identifier(x.get_name()),
-                        expression=QualifiedNameReference(name=QualifiedName(parts=[root_alias, x.get_name()]))
-                    )
-                    for x in self.columns()
-                ],
-                distinct=False
-            ),
-            from_=[
-                AliasedRelation(
-                    relation=Table(name=self.table),
-                    alias=root_alias,
-                    columnNames=[x.get_name() for x in self.columns()]
-                )
-            ],
-            where=None,
-            groupBy=[],
-            having=None,
-            orderBy=[],
-            limit=None,
-            offset=None
-        )
+        TableSpecInputFrameAbstract.__init__(self, table_name_parts=table_name_parts)
+        LegendApiNonExecutableInputTdsFrame.__init__(self, columns=columns)
 
     def __str__(self) -> str:
         return f"LegendApiTableSpecInputFrame({'.'.join(self.table.parts)})"

pylegend/extensions/tds/pandas_api/frames/pandas_api_legend_function_input_frame.py

@@ -0,0 +1,46 @@
+# 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 pylegend._typing import (
+    PyLegendSequence
+)
+from pylegend.core.tds.pandas_api.frames.pandas_api_input_tds_frame import PandasApiExecutableInputTdsFrame
+from pylegend.core.project_cooridnates import ProjectCoordinates
+from pylegend.core.request.legend_client import LegendClient
+from pylegend.extensions.tds.abstract.legend_function_input_frame import LegendFunctionInputFrameAbstract
+
+
+__all__: PyLegendSequence[str] = [
+    "PandasApiLegendFunctionInputFrame"
+]
+
+
+class PandasApiLegendFunctionInputFrame(LegendFunctionInputFrameAbstract, PandasApiExecutableInputTdsFrame):
+
+    def __init__(
+            self,
+            path: str,
+            project_coordinates: ProjectCoordinates,
+            legend_client: LegendClient,
+    ) -> None:
+        LegendFunctionInputFrameAbstract.__init__(self, path=path, project_coordinates=project_coordinates)
+        PandasApiExecutableInputTdsFrame.__init__(
+            self,
+            legend_client=legend_client,
+            columns=legend_client.get_sql_string_schema(self.to_sql_query())
+        )
+        LegendFunctionInputFrameAbstract.set_initialized(self, True)
+
+    def __str__(self) -> str:
+        return f"PandasApiLegendFunctionInputFrame({'.'.join(self.get_path())})"

pylegend/extensions/tds/pandas_api/frames/pandas_api_legend_service_input_frame.py

@@ -0,0 +1,46 @@
+# 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 pylegend._typing import (
+    PyLegendSequence
+)
+from pylegend.core.tds.pandas_api.frames.pandas_api_input_tds_frame import PandasApiExecutableInputTdsFrame
+from pylegend.core.project_cooridnates import ProjectCoordinates
+from pylegend.core.request.legend_client import LegendClient
+from pylegend.extensions.tds.abstract.legend_service_input_frame import LegendServiceInputFrameAbstract
+
+
+__all__: PyLegendSequence[str] = [
+    "PandasApiLegendServiceInputFrame"
+]
+
+
+class PandasApiLegendServiceInputFrame(LegendServiceInputFrameAbstract, PandasApiExecutableInputTdsFrame):
+
+    def __init__(
+            self,
+            pattern: str,
+            project_coordinates: ProjectCoordinates,
+            legend_client: LegendClient,
+    ) -> None:
+        LegendServiceInputFrameAbstract.__init__(self, pattern=pattern, project_coordinates=project_coordinates)
+        PandasApiExecutableInputTdsFrame.__init__(
+            self,
+            legend_client=legend_client,
+            columns=legend_client.get_sql_string_schema(self.to_sql_query())
+        )
+        LegendServiceInputFrameAbstract.set_initialized(self, True)
+
+    def __str__(self) -> str:
+        return f"PandasApiLegendServiceInputFrame({'.'.join(self.get_pattern())})"

pylegend/extensions/tds/pandas_api/frames/pandas_api_table_spec_input_frame.py

@@ -16,18 +16,9 @@ from pylegend._typing import (
     PyLegendList,
     PyLegendSequence
 )
-from pylegend.core.sql.metamodel import (
-    QualifiedName,
-    QualifiedNameReference,
-    QuerySpecification,
-    Select,
-    SingleColumn,
-    Table,
-    AliasedRelation
-)
 from pylegend.core.tds.pandas_api.frames.pandas_api_input_tds_frame import PandasApiNonExecutableInputTdsFrame
 from pylegend.core.tds.tds_column import TdsColumn
-from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.extensions.tds.abstract.table_spec_input_frame import TableSpecInputFrameAbstract
 
 
 __all__: PyLegendSequence[str] = [
@@ -35,41 +26,11 @@ __all__: PyLegendSequence[str] = [
 ]
 
 
-class PandasApiTableSpecInputFrame(PandasApiNonExecutableInputTdsFrame):
-    table: QualifiedName
+class PandasApiTableSpecInputFrame(TableSpecInputFrameAbstract, PandasApiNonExecutableInputTdsFrame):
 
     def __init__(self, table_name_parts: PyLegendList[str], columns: PyLegendSequence[TdsColumn]) -> None:
-        super().__init__(columns=columns)
-        self.table = QualifiedName(table_name_parts)
-
-    def to_sql_query_object(self, config: FrameToSqlConfig) -> QuerySpecification:
-        db_extension = config.sql_to_string_generator().get_db_extension()
-        root_alias = db_extension.quote_identifier("root")
-        return QuerySpecification(
-            select=Select(
-                selectItems=[
-                    SingleColumn(
-                        alias=db_extension.quote_identifier(x.get_name()),
-                        expression=QualifiedNameReference(name=QualifiedName(parts=[root_alias, x.get_name()]))
-                    )
-                    for x in self.columns()
-                ],
-                distinct=False
-            ),
-            from_=[
-                AliasedRelation(
-                    relation=Table(name=self.table),
-                    alias=root_alias,
-                    columnNames=[x.get_name() for x in self.columns()]
-                )
-            ],
-            where=None,
-            groupBy=[],
-            having=None,
-            orderBy=[],
-            limit=None,
-            offset=None
-        )
+        TableSpecInputFrameAbstract.__init__(self, table_name_parts=table_name_parts)
+        PandasApiNonExecutableInputTdsFrame.__init__(self, columns=columns)
 
     def __str__(self) -> str:
         return f"PandasApiTableSpecInputFrame({'.'.join(self.table.parts)})"

pylegend/legend_api_tds_client.py

@@ -0,0 +1,73 @@
+# 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 pylegend._typing import (
+    PyLegendSequence,
+)
+from pylegend.core.request import LegendClient
+from pylegend.core.project_cooridnates import ProjectCoordinates
+from pylegend.core.tds.legend_api.frames.legend_api_tds_frame import LegendApiTdsFrame
+
+
+__all__: PyLegendSequence[str] = [
+    "LegendApiTdsClient",
+    "legend_api_tds_client",
+]
+
+
+class LegendApiTdsClient:
+    __legend_client: LegendClient
+
+    def __init__(
+            self,
+            legend_client: LegendClient
+    ) -> None:
+        self.__legend_client = legend_client
+
+    def legend_service_frame(
+            self,
+            service_pattern: str,
+            project_coordinates: ProjectCoordinates
+    ) -> LegendApiTdsFrame:
+        from pylegend.extensions.tds.legend_api.frames.legend_api_legend_service_input_frame import (
+            LegendApiLegendServiceInputFrame
+        )
+        return LegendApiLegendServiceInputFrame(
+            pattern=service_pattern,
+            project_coordinates=project_coordinates,
+            legend_client=self.__legend_client
+        )
+
+    def legend_function_frame(
+            self,
+            function_path: str,
+            project_coordinates: ProjectCoordinates
+    ) -> LegendApiTdsFrame:
+        from pylegend.extensions.tds.legend_api.frames.legend_api_legend_function_input_frame import (
+            LegendApiLegendFunctionInputFrame
+        )
+        return LegendApiLegendFunctionInputFrame(
+            path=function_path,
+            project_coordinates=project_coordinates,
+            legend_client=self.__legend_client
+        )
+
+
+def legend_api_tds_client(
+        legend_client: LegendClient
+) -> LegendApiTdsClient:
+    return LegendApiTdsClient(
+        legend_client=legend_client
+    )

{pylegend-0.1.0.dist-info → pylegend-0.2.2.dist-info}/METADATA

@@ -1,26 +1,32 @@
 Metadata-Version: 2.1
 Name: pylegend
-Version: 0.1.0
+Version: 0.2.2
 Summary: Python language binding for Legend data management platform
 Home-page: https://github.com/finos/pylegend
 License: Apache-2.0
 Author: PyLegend Maintainers
 Author-email: legend@finos.org
-Requires-Python: >=3.8
+Requires-Python: >=3.8,<3.13
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: ijson (>=3.1.4)
-Requires-Dist: numpy (>=1.20.0)
-Requires-Dist: pandas (>=1.0.0)
+Requires-Dist: numpy (>=1.20.0) ; python_version < "3.12"
+Requires-Dist: numpy (>=1.26.0) ; python_version >= "3.12"
+Requires-Dist: pandas (>=1.0.0) ; python_version < "3.12"
+Requires-Dist: pandas (>=2.1.1) ; python_version >= "3.12"
 Requires-Dist: requests (>=2.27.1)
 Project-URL: Repository, https://github.com/finos/pylegend
 Description-Content-Type: text/markdown
 
 [![FINOS - Incubating](https://cdn.jsdelivr.net/gh/finos/contrib-toolbox@master/images/badge-incubating.svg)](https://community.finos.org/docs/governance/Software-Projects/stages/incubating)
+[![pypi](https://img.shields.io/pypi/v/pylegend.svg)](https://pypi.org/project/pylegend/)
+[![python](https://img.shields.io/badge/python-3.8%20%7C%203.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue)](https://www.python.org/downloads)
+![CI Testing](https://img.shields.io/badge/CI%20Testing-Linux%20%7C%20%20macOS%20%7C%20Windows%20-orange)
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 ![Build](https://github.com/finos/pylegend/workflows/Build%20CI/badge.svg)
 ![CVE Scan](https://github.com/finos/pylegend/workflows/CVE%20Scan/badge.svg)

{pylegend-0.1.0.dist-info → pylegend-0.2.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pylegend/__init__.py,sha256=kUUTGXn35cN0-MKcpxA_1winDqTSnrIiVoGkpDyQMdI,773
+pylegend/__init__.py,sha256=hFFvPRA9R38h7qO-REhP45L5VSCqpJTeSQ83x88LOcU,1475
 pylegend/_typing.py,sha256=3P2K9xyyODrYRx3iDI8jtF1vGGqPbYiKqLEN9bBCdi0,1479
 pylegend/core/__init__.py,sha256=LXTDJSDmHQXtnMDZouhZp9IZQVpY6ONkINbUYjtnMkE,578
 pylegend/core/databse/__init__.py,sha256=LXTDJSDmHQXtnMDZouhZp9IZQVpY6ONkINbUYjtnMkE,578
@@ -6,8 +6,8 @@ pylegend/core/databse/sql_to_string/__init__.py,sha256=LPvE3XwipxzoTLD5Iw0pQXHbq
 pylegend/core/databse/sql_to_string/config.py,sha256=xrwPFcuZyzZcKNGeOQTnFW2y7CqhT6laSAazVl93JLU,1384
 pylegend/core/databse/sql_to_string/db_extension.py,sha256=KrliUcObJfKucHRxVNVV5FDGwZm9U7yH0T0TCQmIDy8,52468
 pylegend/core/databse/sql_to_string/generator.py,sha256=Tlz9ta3cY_LzZhe8XHn0afgsfV36Pd-bLyUng-oIprs,2605
-pylegend/core/language/__init__.py,sha256=f8GKgTChl3uOFJg9S8gp6HJM13T5D2-R0D-pSfB7iUQ,4166
-pylegend/core/language/aggregate_specification.py,sha256=a16Fd9Lsd7EXsnSTjUmTF1cYYGmKpGDBiFcnpCrh8fk,1805
+pylegend/core/language/__init__.py,sha256=DPhfz3HDui64H5ez954pMvjK66h2LUozPVTi2kePCtE,4182
+pylegend/core/language/aggregate_specification.py,sha256=3AJKZ9f2mi9n-nbHY8zo6T2ecKCixYzYUV82jyWVNG0,2119
 pylegend/core/language/column_expressions.py,sha256=YfLs-h0NVDKiKSdIhGe0dlDQ3u24KCJB38fviuI_di4,4335
 pylegend/core/language/expression.py,sha256=0fl0l1RnvkbyqfWbMAB_5VjL4Y21NeRkjq3eMCooFds,2225
 pylegend/core/language/functions.py,sha256=vp-JhTn6ITEKD1wpvcppzsYV_T3UVaIp0IzQYkhmgMM,1159
@@ -36,10 +36,12 @@ pylegend/core/language/primitives/primitive.py,sha256=YTN56bdI9uyz5WBAO4oCfZM-9u
 pylegend/core/language/primitives/strictdate.py,sha256=QUbUMMIViSC0HMBPUDXfFqbYiv4eE4r67fjFMsJTiFY,2490
 pylegend/core/language/primitives/string.py,sha256=riI340Iytk7zfThbPIfnJ3dyGnOZycfHM05jtKIgewQ,8341
 pylegend/core/language/tds_row.py,sha256=lrf129CatediTnbEh_d_IAIWjddoywxer_1L6fsBtUY,8175
-pylegend/core/request/__init__.py,sha256=LXTDJSDmHQXtnMDZouhZp9IZQVpY6ONkINbUYjtnMkE,578
-pylegend/core/request/legend_client.py,sha256=WXUqAPQ5wXXbLfGQFZ1wIidgHX8yXv_oR1MweJIRHwk,2391
+pylegend/core/project_cooridnates.py,sha256=t1G6gJzcRQRbCjGpCOk0vBiqd0F8Y_e15Nu4NuzYd6I,3751
+pylegend/core/request/__init__.py,sha256=IHt1dQ2lEa7ibDgZC2jUAnGXG_lG-UOC_I4V7JkC6qk,967
+pylegend/core/request/auth.py,sha256=IuoRYqolYPQA83lQuoOk7_7lPlJPvMeKovbpZwM8pm0,1701
+pylegend/core/request/legend_client.py,sha256=upAAQt9Zhtf_oczlfV-LoWR7cm7y5bsGVf2p2aU7s_E,2773
 pylegend/core/request/response_reader.py,sha256=TNMi2GKk4lkmf7VMeY5n2AwhxxuWbX4M8pgC2_pXFbE,1691
-pylegend/core/request/service_client.py,sha256=Qy1OwaGHFauxpeMtUxhM6TFhyevA5TZZp0c_MXciFvU,2870
+pylegend/core/request/service_client.py,sha256=oNvMR6qNl5UcxpcAjIb4CCpd0MB3Z-Y5OJSyFPGeerM,3377
 pylegend/core/sql/__init__.py,sha256=LXTDJSDmHQXtnMDZouhZp9IZQVpY6ONkINbUYjtnMkE,578
 pylegend/core/sql/metamodel.py,sha256=B7aqblDyyiTsqWZUW2Is9_2FHTsYTkvhJ1FVxXxoSF8,20134
 pylegend/core/sql/metamodel_extension.py,sha256=A3B1anMf1x54sjBIjZJhQWXX5IKIsQXFYaL5vWJC4ow,15348
@@ -79,7 +81,7 @@ pylegend/core/tds/result_handler/to_csv_file_result_handler.py,sha256=lm0UG87RNU
 pylegend/core/tds/result_handler/to_json_file_result_handler.py,sha256=6Qc6hxNvWhceMeIE8skdwcY5V_dLJ7YHmxV37W6MRdo,1357
 pylegend/core/tds/result_handler/to_string_result_handler.py,sha256=y7xlSahtrsMhzFU2aPHgoT2NKm-Jn7RC2rEZmbYfYTY,1142
 pylegend/core/tds/sql_query_helpers.py,sha256=9uN6I8D-fLdqVbkJb5gWm0wU-QrKDdtH4pdM_Njn55c,3614
-pylegend/core/tds/tds_column.py,sha256=Rg27xqwY2SvOWLtqqBCPg0Fgboh0D7FEnzO7RJIJo0U,5265
+pylegend/core/tds/tds_column.py,sha256=Kyi39cO0X9lFOom1m0gC4GrWBSmzlMj4BMT-9x_cG3A,5231
 pylegend/core/tds/tds_frame.py,sha256=xQHjlFF7OQvENDCfhg3wwcgHrWFCFyuZWbMJcFtFeH0,2745
 pylegend/extensions/__init__.py,sha256=LXTDJSDmHQXtnMDZouhZp9IZQVpY6ONkINbUYjtnMkE,578
 pylegend/extensions/database/__init__.py,sha256=LXTDJSDmHQXtnMDZouhZp9IZQVpY6ONkINbUYjtnMkE,578
@@ -87,18 +89,27 @@ pylegend/extensions/database/vendors/__init__.py,sha256=LXTDJSDmHQXtnMDZouhZp9IZ
 pylegend/extensions/database/vendors/postgres/__init__.py,sha256=LXTDJSDmHQXtnMDZouhZp9IZQVpY6ONkINbUYjtnMkE,578
 pylegend/extensions/database/vendors/postgres/postgres_sql_to_string.py,sha256=u4ct89lOjpi5yP7A_-HpvfuJ6C7k62Q0WnfOhhYm8yg,1340
 pylegend/extensions/tds/__init__.py,sha256=LXTDJSDmHQXtnMDZouhZp9IZQVpY6ONkINbUYjtnMkE,578
+pylegend/extensions/tds/abstract/__init__.py,sha256=LXTDJSDmHQXtnMDZouhZp9IZQVpY6ONkINbUYjtnMkE,578
+pylegend/extensions/tds/abstract/legend_function_input_frame.py,sha256=5oj5q-tVqsT86tBYDFdr3KV4P0f8eOuv_BbJpyc4LAI,3428
+pylegend/extensions/tds/abstract/legend_service_input_frame.py,sha256=ho-jiUYpYJazVtWxc7Cdtk3B7A5-LI5b-PYu0osS4go,3453
+pylegend/extensions/tds/abstract/table_spec_input_frame.py,sha256=MMaMdk_XVVW4jwKLnkHET7s6HkZl_WfLlFZUHLvt5Gc,2326
 pylegend/extensions/tds/legend_api/__init__.py,sha256=LXTDJSDmHQXtnMDZouhZp9IZQVpY6ONkINbUYjtnMkE,578
 pylegend/extensions/tds/legend_api/frames/__init__.py,sha256=LXTDJSDmHQXtnMDZouhZp9IZQVpY6ONkINbUYjtnMkE,578
-pylegend/extensions/tds/legend_api/frames/legend_api_table_spec_input_frame.py,sha256=b7czYczx3ugI45JjBZZ2mv3jgGOc3Y-pHVJQQmdQoAk,2596
+pylegend/extensions/tds/legend_api/frames/legend_api_legend_function_input_frame.py,sha256=0pQHk9SsJcND8oCWwhjBEHPxh6ddjwak8MLEmVKoFnw,1818
+pylegend/extensions/tds/legend_api/frames/legend_api_legend_service_input_frame.py,sha256=1-vR9sES55ZGkylGHlNTPrkq1aWRnsZrt3kCvXFftTo,1823
+pylegend/extensions/tds/legend_api/frames/legend_api_table_spec_input_frame.py,sha256=fdcs00l2LKcEhrsnpjIfKzHPenucVeALGkSniVxdx_Q,1465
 pylegend/extensions/tds/pandas_api/__init__.py,sha256=LXTDJSDmHQXtnMDZouhZp9IZQVpY6ONkINbUYjtnMkE,578
 pylegend/extensions/tds/pandas_api/frames/__init__.py,sha256=LXTDJSDmHQXtnMDZouhZp9IZQVpY6ONkINbUYjtnMkE,578
-pylegend/extensions/tds/pandas_api/frames/pandas_api_table_spec_input_frame.py,sha256=HkxeDUWY2kugYV0xp5_75exus0CY6nINgQfOBCb_S_w,2596
+pylegend/extensions/tds/pandas_api/frames/pandas_api_legend_function_input_frame.py,sha256=aJaNPJcfMdc8HTJKErah4BYSnHfmKMIMvoKtEeCx4zQ,1818
+pylegend/extensions/tds/pandas_api/frames/pandas_api_legend_service_input_frame.py,sha256=dOV6qXIrNkZ8gwmPt0ljr5CVViS4AH5Y4h3L-1WnNdM,1822
+pylegend/extensions/tds/pandas_api/frames/pandas_api_table_spec_input_frame.py,sha256=2pj-siOOvIFEqNOG-f4VUvhY9gBGUFFDZz7jZl7QpLg,1465
 pylegend/extensions/tds/result_handler/__init__.py,sha256=NIIUcl39wpSc51IhUUEKtEYlve89Xncq0YEG78Gren4,864
 pylegend/extensions/tds/result_handler/to_pandas_df_result_handler.py,sha256=tvVsxDOzHNTvzjdApIhmeefws5_u0N8Rqm7UvEtj70w,4958
+pylegend/legend_api_tds_client.py,sha256=I0uRF7ADGvV5fHN-dEBIrdxTy7GC8jV91V62rgXn6c0,2319
 pylegend/utils/__init__.py,sha256=LXTDJSDmHQXtnMDZouhZp9IZQVpY6ONkINbUYjtnMkE,578
 pylegend/utils/class_utils.py,sha256=t4PpF3jAXS_D6p9TqlSppryNYNOuy5C-kbKn2Kgb4QU,973
-pylegend-0.1.0.dist-info/LICENSE,sha256=AGR96_qQPZO66Gjqq4G6r_g670K35VtW-IobTAkmZJM,11343
-pylegend-0.1.0.dist-info/LICENSE.spdx,sha256=i7TsBclLotUvMjx9vZ_6S8Pp0r4uknWGw1RwiKBBvQ4,207
-pylegend-0.1.0.dist-info/METADATA,sha256=KPcgW_QcwcmoLuFIWL_6ydYHVD7E8qz7jqghlu7yvEM,3701
-pylegend-0.1.0.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
-pylegend-0.1.0.dist-info/RECORD,,
+pylegend-0.2.2.dist-info/LICENSE,sha256=AGR96_qQPZO66Gjqq4G6r_g670K35VtW-IobTAkmZJM,11343
+pylegend-0.2.2.dist-info/LICENSE.spdx,sha256=i7TsBclLotUvMjx9vZ_6S8Pp0r4uknWGw1RwiKBBvQ4,207
+pylegend-0.2.2.dist-info/METADATA,sha256=lmfSjBstKvYcjXXTrlAkhGfvA3llmC_iOxK2SYbx8t8,4267
+pylegend-0.2.2.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+pylegend-0.2.2.dist-info/RECORD,,

{pylegend-0.1.0.dist-info → pylegend-0.2.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.7.0
+Generator: poetry-core 1.8.1
 Root-Is-Purelib: true
 Tag: py3-none-any