luminesce-sdk 2.4.2__py3-none-any.whl → 2.4.6__py3-none-any.whl

luminesce/api/sql_execution_api.py

@@ -444,22 +444,22 @@ class SqlExecutionApi:
 
 
     @overload
-    async def get_by_query_json(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, **kwargs) -> str:  # noqa: E501
+    async def get_by_query_json(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, include_lineage : Annotated[Optional[StrictBool], Field(description="Should lineage be included? If true this will be `properJson` and the jsonProper flag ignored")] = None, **kwargs) -> str:  # noqa: E501
         ...
 
     @overload
-    def get_by_query_json(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, async_req: Optional[bool]=True, **kwargs) -> str:  # noqa: E501
+    def get_by_query_json(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, include_lineage : Annotated[Optional[StrictBool], Field(description="Should lineage be included? If true this will be `properJson` and the jsonProper flag ignored")] = None, async_req: Optional[bool]=True, **kwargs) -> str:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_by_query_json(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[str, Awaitable[str]]:  # noqa: E501
+    def get_by_query_json(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, include_lineage : Annotated[Optional[StrictBool], Field(description="Should lineage be included? If true this will be `properJson` and the jsonProper flag ignored")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[str, Awaitable[str]]:  # noqa: E501
         """GetByQueryJson: Execute Sql from the url returning JSON  # noqa: E501
 
          Returns data from a simple single-line query execution which is specified on the url. e.g. `select ^ from Sys.Field order by 1, 2`, returned in the format of the method name.  The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden   # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.get_by_query_json(query, scalar_parameters, query_name, timeout, json_proper, async_req=True)
+        >>> thread = api.get_by_query_json(query, scalar_parameters, query_name, timeout, json_proper, include_lineage, async_req=True)
         >>> result = thread.get()
 
         :param query: LuminesceSql to Execute (must be one line only) (required)
@@ -472,6 +472,8 @@ class SqlExecutionApi:
         :type timeout: int
         :param json_proper: Should this be text/json (not json-encoded-as-a-string)
         :type json_proper: bool
+        :param include_lineage: Should lineage be included? If true this will be `properJson` and the jsonProper flag ignored
+        :type include_lineage: bool
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
@@ -488,17 +490,17 @@ class SqlExecutionApi:
             raise ValueError(message)
         if async_req is not None:
             kwargs['async_req'] = async_req
-        return self.get_by_query_json_with_http_info(query, scalar_parameters, query_name, timeout, json_proper, **kwargs)  # noqa: E501
+        return self.get_by_query_json_with_http_info(query, scalar_parameters, query_name, timeout, json_proper, include_lineage, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_by_query_json_with_http_info(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_by_query_json_with_http_info(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, include_lineage : Annotated[Optional[StrictBool], Field(description="Should lineage be included? If true this will be `properJson` and the jsonProper flag ignored")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """GetByQueryJson: Execute Sql from the url returning JSON  # noqa: E501
 
          Returns data from a simple single-line query execution which is specified on the url. e.g. `select ^ from Sys.Field order by 1, 2`, returned in the format of the method name.  The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden   # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.get_by_query_json_with_http_info(query, scalar_parameters, query_name, timeout, json_proper, async_req=True)
+        >>> thread = api.get_by_query_json_with_http_info(query, scalar_parameters, query_name, timeout, json_proper, include_lineage, async_req=True)
         >>> result = thread.get()
 
         :param query: LuminesceSql to Execute (must be one line only) (required)
@@ -511,6 +513,8 @@ class SqlExecutionApi:
         :type timeout: int
         :param json_proper: Should this be text/json (not json-encoded-as-a-string)
         :type json_proper: bool
+        :param include_lineage: Should lineage be included? If true this will be `properJson` and the jsonProper flag ignored
+        :type include_lineage: bool
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the ApiResponse.data will
@@ -542,7 +546,8 @@ class SqlExecutionApi:
             'scalar_parameters',
             'query_name',
             'timeout',
-            'json_proper'
+            'json_proper',
+            'include_lineage'
         ]
         _all_params.extend(
             [
@@ -589,6 +594,9 @@ class SqlExecutionApi:
         if _params.get('json_proper') is not None:  # noqa: E501
             _query_params.append(('jsonProper', _params['json_proper']))
 
+        if _params.get('include_lineage') is not None:  # noqa: E501
+            _query_params.append(('includeLineage', _params['include_lineage']))
+
         # process the header parameters
         _header_params = dict(_params.get('_headers', {}))
         # process the form parameters
@@ -1769,22 +1777,22 @@ class SqlExecutionApi:
 
 
     @overload
-    async def put_by_query_json(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, **kwargs) -> str:  # noqa: E501
+    async def put_by_query_json(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, include_lineage : Annotated[Optional[StrictBool], Field(description="Should lineage be included? If true this will be `properJson` and the jsonProper flag ignored")] = None, **kwargs) -> str:  # noqa: E501
         ...
 
     @overload
-    def put_by_query_json(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, async_req: Optional[bool]=True, **kwargs) -> str:  # noqa: E501
+    def put_by_query_json(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, include_lineage : Annotated[Optional[StrictBool], Field(description="Should lineage be included? If true this will be `properJson` and the jsonProper flag ignored")] = None, async_req: Optional[bool]=True, **kwargs) -> str:  # noqa: E501
         ...
 
     @validate_arguments
-    def put_by_query_json(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[str, Awaitable[str]]:  # noqa: E501
+    def put_by_query_json(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, include_lineage : Annotated[Optional[StrictBool], Field(description="Should lineage be included? If true this will be `properJson` and the jsonProper flag ignored")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[str, Awaitable[str]]:  # noqa: E501
         """PutByQueryJson: Execute Sql from the body returning JSON  # noqa: E501
 
          For more complex LuminesceSql a PUT will allow for longer and line break delimited Sql, whic will be returned in the format of the method name. e.g.: ```sql @@cutoff = select #2020-02-01#; @issues = select Id, SortId, Summary, Created, Updated from Dev.Jira.Issue where Project='HC' and Created < @@cutoff and Updated > @@cutoff;  select i.Id, i.SortId, i.Summary, LinkText, LinkedIssueId, LinkedIssueSortId, LinkedIssueSummary from @issues i inner join Dev.Jira.Issue.Link li     on i.Id = li.IssueId ```  The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden   # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.put_by_query_json(body, scalar_parameters, query_name, timeout_seconds, json_proper, async_req=True)
+        >>> thread = api.put_by_query_json(body, scalar_parameters, query_name, timeout_seconds, json_proper, include_lineage, async_req=True)
         >>> result = thread.get()
 
         :param body: LuminesceSql to Execute (may be multi-line) (required)
@@ -1797,6 +1805,8 @@ class SqlExecutionApi:
         :type timeout_seconds: int
         :param json_proper: Should this be text/json (not json-encoded-as-a-string)
         :type json_proper: bool
+        :param include_lineage: Should lineage be included? If true this will be `properJson` and the jsonProper flag ignored
+        :type include_lineage: bool
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
@@ -1813,17 +1823,17 @@ class SqlExecutionApi:
             raise ValueError(message)
         if async_req is not None:
             kwargs['async_req'] = async_req
-        return self.put_by_query_json_with_http_info(body, scalar_parameters, query_name, timeout_seconds, json_proper, **kwargs)  # noqa: E501
+        return self.put_by_query_json_with_http_info(body, scalar_parameters, query_name, timeout_seconds, json_proper, include_lineage, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def put_by_query_json_with_http_info(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def put_by_query_json_with_http_info(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, include_lineage : Annotated[Optional[StrictBool], Field(description="Should lineage be included? If true this will be `properJson` and the jsonProper flag ignored")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """PutByQueryJson: Execute Sql from the body returning JSON  # noqa: E501
 
          For more complex LuminesceSql a PUT will allow for longer and line break delimited Sql, whic will be returned in the format of the method name. e.g.: ```sql @@cutoff = select #2020-02-01#; @issues = select Id, SortId, Summary, Created, Updated from Dev.Jira.Issue where Project='HC' and Created < @@cutoff and Updated > @@cutoff;  select i.Id, i.SortId, i.Summary, LinkText, LinkedIssueId, LinkedIssueSortId, LinkedIssueSummary from @issues i inner join Dev.Jira.Issue.Link li     on i.Id = li.IssueId ```  The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden   # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.put_by_query_json_with_http_info(body, scalar_parameters, query_name, timeout_seconds, json_proper, async_req=True)
+        >>> thread = api.put_by_query_json_with_http_info(body, scalar_parameters, query_name, timeout_seconds, json_proper, include_lineage, async_req=True)
         >>> result = thread.get()
 
         :param body: LuminesceSql to Execute (may be multi-line) (required)
@@ -1836,6 +1846,8 @@ class SqlExecutionApi:
         :type timeout_seconds: int
         :param json_proper: Should this be text/json (not json-encoded-as-a-string)
         :type json_proper: bool
+        :param include_lineage: Should lineage be included? If true this will be `properJson` and the jsonProper flag ignored
+        :type include_lineage: bool
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the ApiResponse.data will
@@ -1867,7 +1879,8 @@ class SqlExecutionApi:
             'scalar_parameters',
             'query_name',
             'timeout_seconds',
-            'json_proper'
+            'json_proper',
+            'include_lineage'
         ]
         _all_params.extend(
             [
@@ -1911,6 +1924,9 @@ class SqlExecutionApi:
         if _params.get('json_proper') is not None:  # noqa: E501
             _query_params.append(('jsonProper', _params['json_proper']))
 
+        if _params.get('include_lineage') is not None:  # noqa: E501
+            _query_params.append(('includeLineage', _params['include_lineage']))
+
         # process the header parameters
         _header_params = dict(_params.get('_headers', {}))
         # process the form parameters

luminesce/configuration.py

@@ -445,7 +445,7 @@ class Configuration:
         return "Python SDK Debug Report:\n"\
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
-               "Version of the API: 1.19.79\n"\
+               "Version of the API: 1.19.160\n"\
                "SDK Package Version: {package_version}".\
                format(env=sys.platform, pyversion=sys.version, package_version=package_version)
 

luminesce/models/__init__.py

@@ -67,6 +67,7 @@ from luminesce.models.intellisense_request import IntellisenseRequest
 from luminesce.models.intellisense_response import IntellisenseResponse
 from luminesce.models.intellisense_type import IntellisenseType
 from luminesce.models.joined_table_design import JoinedTableDesign
+from luminesce.models.lineage import Lineage
 from luminesce.models.link import Link
 from luminesce.models.luminesce_binary_type import LuminesceBinaryType
 from luminesce.models.lusid_grid_data import LusidGridData
@@ -90,6 +91,8 @@ from luminesce.models.resource_list_of_access_controlled_resource import Resourc
 from luminesce.models.scalar_parameter import ScalarParameter
 from luminesce.models.source import Source
 from luminesce.models.source_type import SourceType
+from luminesce.models.sql_execution_flags import SqlExecutionFlags
+from luminesce.models.table_lineage import TableLineage
 from luminesce.models.table_meta import TableMeta
 from luminesce.models.table_view import TableView
 from luminesce.models.task_status import TaskStatus
@@ -152,6 +155,7 @@ __all__ = [
     "IntellisenseResponse",
     "IntellisenseType",
     "JoinedTableDesign",
+    "Lineage",
     "Link",
     "LuminesceBinaryType",
     "LusidGridData",
@@ -175,6 +179,8 @@ __all__ = [
     "ScalarParameter",
     "Source",
     "SourceType",
+    "SqlExecutionFlags",
+    "TableLineage",
     "TableMeta",
     "TableView",
     "TaskStatus",

luminesce/models/background_multi_query_response.py

@@ -33,6 +33,7 @@ class BackgroundMultiQueryResponse(BaseModel):
     cancel: Optional[Link] = None
     fetch_json: Optional[List[Link]] = Field(default=None, description="Json (as a string) data request links for all of the child queries", alias="fetchJson")
     fetch_json_proper: Optional[List[Link]] = Field(default=None, description="Json-proper data request links for all of the child queries", alias="fetchJsonProper")
+    fetch_json_proper_with_lineage: Optional[List[Link]] = Field(default=None, description="Json-proper-with-lineage data request links for all of the child queries", alias="fetchJsonProperWithLineage")
     fetch_xml: Optional[List[Link]] = Field(default=None, description="Xml data request links for all of the child queries", alias="fetchXml")
     fetch_parquet: Optional[List[Link]] = Field(default=None, description="Parquet data request links for all of the child queries", alias="fetchParquet")
     fetch_csv: Optional[List[Link]] = Field(default=None, description="CSV data request links for all of the child queries", alias="fetchCsv")
@@ -40,7 +41,7 @@ class BackgroundMultiQueryResponse(BaseModel):
     fetch_excel: Optional[List[Link]] = Field(default=None, description="Excel workbook data request links for all of the child queries", alias="fetchExcel")
     fetch_sqlite: Optional[List[Link]] = Field(default=None, description="SqLite DB data request links for all of the child queries", alias="fetchSqlite")
     histogram: Optional[List[Link]] = Field(default=None, description="Histogram links for all of the child queries")
-    __properties = ["executionId", "progress", "cancel", "fetchJson", "fetchJsonProper", "fetchXml", "fetchParquet", "fetchCsv", "fetchPipe", "fetchExcel", "fetchSqlite", "histogram"]
+    __properties = ["executionId", "progress", "cancel", "fetchJson", "fetchJsonProper", "fetchJsonProperWithLineage", "fetchXml", "fetchParquet", "fetchCsv", "fetchPipe", "fetchExcel", "fetchSqlite", "histogram"]
 
     class Config:
         """Pydantic configuration"""
@@ -75,6 +76,7 @@ class BackgroundMultiQueryResponse(BaseModel):
                             "execution_id",
                             "fetch_json",
                             "fetch_json_proper",
+                            "fetch_json_proper_with_lineage",
                             "fetch_xml",
                             "fetch_parquet",
                             "fetch_csv",
@@ -104,6 +106,13 @@ class BackgroundMultiQueryResponse(BaseModel):
                 if _item:
                     _items.append(_item.to_dict())
             _dict['fetchJsonProper'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in fetch_json_proper_with_lineage (list)
+        _items = []
+        if self.fetch_json_proper_with_lineage:
+            for _item in self.fetch_json_proper_with_lineage:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['fetchJsonProperWithLineage'] = _items
         # override the default output from pydantic by calling `to_dict()` of each item in fetch_xml (list)
         _items = []
         if self.fetch_xml:
@@ -163,6 +172,11 @@ class BackgroundMultiQueryResponse(BaseModel):
         if self.fetch_json_proper is None and "fetch_json_proper" in self.__fields_set__:
             _dict['fetchJsonProper'] = None
 
+        # set to None if fetch_json_proper_with_lineage (nullable) is None
+        # and __fields_set__ contains the field
+        if self.fetch_json_proper_with_lineage is None and "fetch_json_proper_with_lineage" in self.__fields_set__:
+            _dict['fetchJsonProperWithLineage'] = None
+
         # set to None if fetch_xml (nullable) is None
         # and __fields_set__ contains the field
         if self.fetch_xml is None and "fetch_xml" in self.__fields_set__:
@@ -215,6 +229,7 @@ class BackgroundMultiQueryResponse(BaseModel):
             "cancel": Link.from_dict(obj.get("cancel")) if obj.get("cancel") is not None else None,
             "fetch_json": [Link.from_dict(_item) for _item in obj.get("fetchJson")] if obj.get("fetchJson") is not None else None,
             "fetch_json_proper": [Link.from_dict(_item) for _item in obj.get("fetchJsonProper")] if obj.get("fetchJsonProper") is not None else None,
+            "fetch_json_proper_with_lineage": [Link.from_dict(_item) for _item in obj.get("fetchJsonProperWithLineage")] if obj.get("fetchJsonProperWithLineage") is not None else None,
             "fetch_xml": [Link.from_dict(_item) for _item in obj.get("fetchXml")] if obj.get("fetchXml") is not None else None,
             "fetch_parquet": [Link.from_dict(_item) for _item in obj.get("fetchParquet")] if obj.get("fetchParquet") is not None else None,
             "fetch_csv": [Link.from_dict(_item) for _item in obj.get("fetchCsv")] if obj.get("fetchCsv") is not None else None,

luminesce/models/background_query_progress_response.py

@@ -25,6 +25,7 @@ from datetime import datetime
 from luminesce.models.background_query_state import BackgroundQueryState
 from luminesce.models.column import Column
 from luminesce.models.feedback_event_args import FeedbackEventArgs
+from luminesce.models.table_lineage import TableLineage
 from luminesce.models.task_status import TaskStatus
 
 class BackgroundQueryProgressResponse(BaseModel):
@@ -40,7 +41,8 @@ class BackgroundQueryProgressResponse(BaseModel):
     query:  Optional[StrictStr] = Field(None,alias="query", description="The LuminesceSql of the original request") 
     query_name:  Optional[StrictStr] = Field(None,alias="queryName", description="The QueryName given in the original request") 
     columns_available: Optional[List[Column]] = Field(default=None, description="When HasData is true this is the schema of columns that will be returned if the data is requested", alias="columnsAvailable")
-    __properties = ["hasData", "rowCount", "status", "state", "progress", "feedback", "query", "queryName", "columnsAvailable"]
+    lineage: Optional[TableLineage] = None
+    __properties = ["hasData", "rowCount", "status", "state", "progress", "feedback", "query", "queryName", "columnsAvailable", "lineage"]
 
     class Config:
         """Pydantic configuration"""
@@ -88,6 +90,9 @@ class BackgroundQueryProgressResponse(BaseModel):
                 if _item:
                     _items.append(_item.to_dict())
             _dict['columnsAvailable'] = _items
+        # override the default output from pydantic by calling `to_dict()` of lineage
+        if self.lineage:
+            _dict['lineage'] = self.lineage.to_dict()
         # set to None if progress (nullable) is None
         # and __fields_set__ contains the field
         if self.progress is None and "progress" in self.__fields_set__:
@@ -133,7 +138,8 @@ class BackgroundQueryProgressResponse(BaseModel):
             "feedback": [FeedbackEventArgs.from_dict(_item) for _item in obj.get("feedback")] if obj.get("feedback") is not None else None,
             "query": obj.get("query"),
             "query_name": obj.get("queryName"),
-            "columns_available": [Column.from_dict(_item) for _item in obj.get("columnsAvailable")] if obj.get("columnsAvailable") is not None else None
+            "columns_available": [Column.from_dict(_item) for _item in obj.get("columnsAvailable")] if obj.get("columnsAvailable") is not None else None,
+            "lineage": TableLineage.from_dict(obj.get("lineage")) if obj.get("lineage") is not None else None
         })
         return _obj
 

luminesce/models/background_query_response.py

@@ -33,6 +33,7 @@ class BackgroundQueryResponse(BaseModel):
     cancel: Optional[Link] = None
     fetch_json: Optional[Link] = Field(default=None, alias="fetchJson")
     fetch_json_proper: Optional[Link] = Field(default=None, alias="fetchJsonProper")
+    fetch_json_proper_with_lineage: Optional[Link] = Field(default=None, alias="fetchJsonProperWithLineage")
     fetch_xml: Optional[Link] = Field(default=None, alias="fetchXml")
     fetch_parquet: Optional[Link] = Field(default=None, alias="fetchParquet")
     fetch_csv: Optional[Link] = Field(default=None, alias="fetchCsv")
@@ -40,7 +41,7 @@ class BackgroundQueryResponse(BaseModel):
     fetch_excel: Optional[Link] = Field(default=None, alias="fetchExcel")
     fetch_sqlite: Optional[Link] = Field(default=None, alias="fetchSqlite")
     histogram: Optional[Link] = None
-    __properties = ["executionId", "progress", "cancel", "fetchJson", "fetchJsonProper", "fetchXml", "fetchParquet", "fetchCsv", "fetchPipe", "fetchExcel", "fetchSqlite", "histogram"]
+    __properties = ["executionId", "progress", "cancel", "fetchJson", "fetchJsonProper", "fetchJsonProperWithLineage", "fetchXml", "fetchParquet", "fetchCsv", "fetchPipe", "fetchExcel", "fetchSqlite", "histogram"]
 
     class Config:
         """Pydantic configuration"""
@@ -86,6 +87,9 @@ class BackgroundQueryResponse(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of fetch_json_proper
         if self.fetch_json_proper:
             _dict['fetchJsonProper'] = self.fetch_json_proper.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of fetch_json_proper_with_lineage
+        if self.fetch_json_proper_with_lineage:
+            _dict['fetchJsonProperWithLineage'] = self.fetch_json_proper_with_lineage.to_dict()
         # override the default output from pydantic by calling `to_dict()` of fetch_xml
         if self.fetch_xml:
             _dict['fetchXml'] = self.fetch_xml.to_dict()
@@ -129,6 +133,7 @@ class BackgroundQueryResponse(BaseModel):
             "cancel": Link.from_dict(obj.get("cancel")) if obj.get("cancel") is not None else None,
             "fetch_json": Link.from_dict(obj.get("fetchJson")) if obj.get("fetchJson") is not None else None,
             "fetch_json_proper": Link.from_dict(obj.get("fetchJsonProper")) if obj.get("fetchJsonProper") is not None else None,
+            "fetch_json_proper_with_lineage": Link.from_dict(obj.get("fetchJsonProperWithLineage")) if obj.get("fetchJsonProperWithLineage") is not None else None,
             "fetch_xml": Link.from_dict(obj.get("fetchXml")) if obj.get("fetchXml") is not None else None,
             "fetch_parquet": Link.from_dict(obj.get("fetchParquet")) if obj.get("fetchParquet") is not None else None,
             "fetch_csv": Link.from_dict(obj.get("fetchCsv")) if obj.get("fetchCsv") is not None else None,

luminesce/models/column.py

@@ -24,6 +24,7 @@ from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat
 from datetime import datetime
 from luminesce.models.condition_attributes import ConditionAttributes
 from luminesce.models.data_type import DataType
+from luminesce.models.lineage import Lineage
 
 class Column(BaseModel):
     """
@@ -33,6 +34,7 @@ class Column(BaseModel):
     is_main: Optional[StrictBool] = Field(default=None, alias="isMain")
     is_required_by_provider: Optional[StrictBool] = Field(default=None, alias="isRequiredByProvider")
     mandatory_for_actions:  Optional[StrictStr] = Field(None,alias="mandatoryForActions") 
+    lineage: Optional[Lineage] = None
     name:  Optional[StrictStr] = Field(None,alias="name") 
     type: Optional[DataType] = None
     description:  Optional[StrictStr] = Field(None,alias="description") 
@@ -40,7 +42,7 @@ class Column(BaseModel):
     condition_usage: Optional[ConditionAttributes] = Field(default=None, alias="conditionUsage")
     sample_values:  Optional[StrictStr] = Field(None,alias="sampleValues") 
     allowed_values:  Optional[StrictStr] = Field(None,alias="allowedValues") 
-    __properties = ["isPrimaryKey", "isMain", "isRequiredByProvider", "mandatoryForActions", "name", "type", "description", "displayName", "conditionUsage", "sampleValues", "allowedValues"]
+    __properties = ["isPrimaryKey", "isMain", "isRequiredByProvider", "mandatoryForActions", "lineage", "name", "type", "description", "displayName", "conditionUsage", "sampleValues", "allowedValues"]
 
     class Config:
         """Pydantic configuration"""
@@ -74,6 +76,9 @@ class Column(BaseModel):
                           exclude={
                           },
                           exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of lineage
+        if self.lineage:
+            _dict['lineage'] = self.lineage.to_dict()
         # set to None if mandatory_for_actions (nullable) is None
         # and __fields_set__ contains the field
         if self.mandatory_for_actions is None and "mandatory_for_actions" in self.__fields_set__:
@@ -120,6 +125,7 @@ class Column(BaseModel):
             "is_main": obj.get("isMain"),
             "is_required_by_provider": obj.get("isRequiredByProvider"),
             "mandatory_for_actions": obj.get("mandatoryForActions"),
+            "lineage": Lineage.from_dict(obj.get("lineage")) if obj.get("lineage") is not None else None,
             "name": obj.get("name"),
             "type": obj.get("type"),
             "description": obj.get("description"),

luminesce/models/date_parameters.py

@@ -30,8 +30,9 @@ class DateParameters(BaseModel):
     date_from: Optional[datetime] = Field(default=None, description="Parameter to determine the lower bound in a date range", alias="dateFrom")
     date_to: Optional[datetime] = Field(default=None, description="Parameter to determine the upper bound in a date range", alias="dateTo")
     effective_at: Optional[datetime] = Field(default=None, description="EffectiveAt of the dashboard", alias="effectiveAt")
+    effective_from: Optional[datetime] = Field(default=None, description="EffectiveFrom of the dashboard", alias="effectiveFrom")
     as_at: datetime = Field(description="AsAt of the dashboard", alias="asAt")
-    __properties = ["dateFrom", "dateTo", "effectiveAt", "asAt"]
+    __properties = ["dateFrom", "dateTo", "effectiveAt", "effectiveFrom", "asAt"]
 
     class Config:
         """Pydantic configuration"""
@@ -80,6 +81,11 @@ class DateParameters(BaseModel):
         if self.effective_at is None and "effective_at" in self.__fields_set__:
             _dict['effectiveAt'] = None
 
+        # set to None if effective_from (nullable) is None
+        # and __fields_set__ contains the field
+        if self.effective_from is None and "effective_from" in self.__fields_set__:
+            _dict['effectiveFrom'] = None
+
         return _dict
 
     @classmethod
@@ -95,6 +101,7 @@ class DateParameters(BaseModel):
             "date_from": obj.get("dateFrom"),
             "date_to": obj.get("dateTo"),
             "effective_at": obj.get("effectiveAt"),
+            "effective_from": obj.get("effectiveFrom"),
             "as_at": obj.get("asAt")
         })
         return _obj

luminesce/models/lineage.py

@@ -0,0 +1,149 @@
+# coding: utf-8
+
+"""
+    FINBOURNE Luminesce Web API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
+
+class Lineage(BaseModel):
+    """
+    Lineage
+    """
+    type:  Optional[StrictStr] = Field(None,alias="type") 
+    subtype:  Optional[StrictStr] = Field(None,alias="subtype") 
+    alias:  Optional[StrictStr] = Field(None,alias="alias") 
+    display_name:  Optional[StrictStr] = Field(None,alias="displayName") 
+    description:  Optional[StrictStr] = Field(None,alias="description") 
+    documentation_as_html:  Optional[StrictStr] = Field(None,alias="documentationAsHtml") 
+    documentation_as_mark_down:  Optional[StrictStr] = Field(None,alias="documentationAsMarkDown") 
+    full_text:  Optional[StrictStr] = Field(None,alias="fullText") 
+    children: Optional[List[Lineage]] = None
+    __properties = ["type", "subtype", "alias", "displayName", "description", "documentationAsHtml", "documentationAsMarkDown", "fullText", "children"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Lineage:
+        """Create an instance of Lineage from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of each item in children (list)
+        _items = []
+        if self.children:
+            for _item in self.children:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['children'] = _items
+        # set to None if type (nullable) is None
+        # and __fields_set__ contains the field
+        if self.type is None and "type" in self.__fields_set__:
+            _dict['type'] = None
+
+        # set to None if subtype (nullable) is None
+        # and __fields_set__ contains the field
+        if self.subtype is None and "subtype" in self.__fields_set__:
+            _dict['subtype'] = None
+
+        # set to None if alias (nullable) is None
+        # and __fields_set__ contains the field
+        if self.alias is None and "alias" in self.__fields_set__:
+            _dict['alias'] = None
+
+        # set to None if display_name (nullable) is None
+        # and __fields_set__ contains the field
+        if self.display_name is None and "display_name" in self.__fields_set__:
+            _dict['displayName'] = None
+
+        # set to None if description (nullable) is None
+        # and __fields_set__ contains the field
+        if self.description is None and "description" in self.__fields_set__:
+            _dict['description'] = None
+
+        # set to None if documentation_as_html (nullable) is None
+        # and __fields_set__ contains the field
+        if self.documentation_as_html is None and "documentation_as_html" in self.__fields_set__:
+            _dict['documentationAsHtml'] = None
+
+        # set to None if documentation_as_mark_down (nullable) is None
+        # and __fields_set__ contains the field
+        if self.documentation_as_mark_down is None and "documentation_as_mark_down" in self.__fields_set__:
+            _dict['documentationAsMarkDown'] = None
+
+        # set to None if full_text (nullable) is None
+        # and __fields_set__ contains the field
+        if self.full_text is None and "full_text" in self.__fields_set__:
+            _dict['fullText'] = None
+
+        # set to None if children (nullable) is None
+        # and __fields_set__ contains the field
+        if self.children is None and "children" in self.__fields_set__:
+            _dict['children'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> Lineage:
+        """Create an instance of Lineage from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return Lineage.parse_obj(obj)
+
+        _obj = Lineage.parse_obj({
+            "type": obj.get("type"),
+            "subtype": obj.get("subtype"),
+            "alias": obj.get("alias"),
+            "display_name": obj.get("displayName"),
+            "description": obj.get("description"),
+            "documentation_as_html": obj.get("documentationAsHtml"),
+            "documentation_as_mark_down": obj.get("documentationAsMarkDown"),
+            "full_text": obj.get("fullText"),
+            "children": [Lineage.from_dict(_item) for _item in obj.get("children")] if obj.get("children") is not None else None
+        })
+        return _obj
+
+Lineage.update_forward_refs()

luminesce/models/luminesce_binary_type.py

@@ -37,6 +37,7 @@ class LuminesceBinaryType(str, Enum):
     PYTHON_PROVIDERS = 'Python_Providers'
     AWS_S3_PROVIDERS = 'AwsS3_Providers'
     AZURE_PROVIDERS = 'Azure_Providers'
+    GCS_PROVIDERS = 'Gcs_Providers'
     SQL_DB_PROVIDERS_DB2_LINUX = 'SqlDb_Providers_Db2Linux'
     SQL_DB_PROVIDERS_MY_SQL = 'SqlDb_Providers_MySql'
     SQL_DB_PROVIDERS_ORACLE = 'SqlDb_Providers_Oracle'