pylegend 0.1.0__tar.gz → 0.2.2__tar.gz

{pylegend-0.1.0 → pylegend-0.2.2}/PKG-INFO

@@ -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 → pylegend-0.2.2}/README.md

@@ -1,4 +1,7 @@
 [![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.2.2/pylegend/__init__.py

@@ -0,0 +1,57 @@
+# 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.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__",
+
+    "LegendApiTdsClient",
+    "legend_api_tds_client",
+
+    "LegendClient",
+    "AuthScheme",
+    "LocalhostEmptyAuthScheme",
+    "ResponseReader",
+
+    "VersionedProjectCoordinates",
+    "PersonalWorkspaceProjectCoordinates",
+    "GroupWorkspaceProjectCoordinates",
+
+    "agg",
+]
+
+
+import importlib.metadata
+
+__version__ = importlib.metadata.version("pylegend")

{pylegend-0.1.0 → pylegend-0.2.2}/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-0.1.0 → pylegend-0.2.2}/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-0.2.2/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-0.1.0/pylegend → pylegend-0.2.2/pylegend/core/request}/__init__.py

@@ -15,13 +15,15 @@
 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] = [
-    "__version__"
-]
+    "LegendClient",
 
+    "AuthScheme",
+    "LocalhostEmptyAuthScheme",
 
-import importlib.metadata
-
-__version__ = importlib.metadata.version("pylegend")
+    "ResponseReader"
+]

pylegend-0.2.2/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-0.1.0 → pylegend-0.2.2}/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-0.1.0 → pylegend-0.2.2}/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-0.1.0 → pylegend-0.2.2}/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-0.2.2/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-0.2.2/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