databricks-sdk 0.42.0__py3-none-any.whl → 0.43.0__py3-none-any.whl

databricks/sdk/service/catalog.py

@@ -6913,12 +6913,17 @@ class TemporaryCredentials:
     """Server time when the credential will expire, in epoch milliseconds. The API client is advised to
     cache the credential given this expiration time."""
 
+    gcp_oauth_token: Optional[GcpOauthToken] = None
+    """GCP temporary credentials for API authentication. Read more at
+    https://developers.google.com/identity/protocols/oauth2/service-account"""
+
     def as_dict(self) -> dict:
         """Serializes the TemporaryCredentials into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.aws_temp_credentials: body['aws_temp_credentials'] = self.aws_temp_credentials.as_dict()
         if self.azure_aad: body['azure_aad'] = self.azure_aad.as_dict()
         if self.expiration_time is not None: body['expiration_time'] = self.expiration_time
+        if self.gcp_oauth_token: body['gcp_oauth_token'] = self.gcp_oauth_token.as_dict()
         return body
 
     def as_shallow_dict(self) -> dict:
@@ -6927,6 +6932,7 @@ class TemporaryCredentials:
         if self.aws_temp_credentials: body['aws_temp_credentials'] = self.aws_temp_credentials
         if self.azure_aad: body['azure_aad'] = self.azure_aad
         if self.expiration_time is not None: body['expiration_time'] = self.expiration_time
+        if self.gcp_oauth_token: body['gcp_oauth_token'] = self.gcp_oauth_token
         return body
 
     @classmethod
@@ -6934,7 +6940,8 @@ class TemporaryCredentials:
         """Deserializes the TemporaryCredentials from a dictionary."""
         return cls(aws_temp_credentials=_from_dict(d, 'aws_temp_credentials', AwsCredentials),
                    azure_aad=_from_dict(d, 'azure_aad', AzureActiveDirectoryToken),
-                   expiration_time=d.get('expiration_time', None))
+                   expiration_time=d.get('expiration_time', None),
+                   gcp_oauth_token=_from_dict(d, 'gcp_oauth_token', GcpOauthToken))
 
 
 @dataclass
@@ -7043,6 +7050,9 @@ class UpdateCatalog:
     new_name: Optional[str] = None
     """New name for the catalog."""
 
+    options: Optional[Dict[str, str]] = None
+    """A map of key-value properties attached to the securable."""
+
     owner: Optional[str] = None
     """Username of current owner of catalog."""
 
@@ -7058,6 +7068,7 @@ class UpdateCatalog:
         if self.isolation_mode is not None: body['isolation_mode'] = self.isolation_mode.value
         if self.name is not None: body['name'] = self.name
         if self.new_name is not None: body['new_name'] = self.new_name
+        if self.options: body['options'] = self.options
         if self.owner is not None: body['owner'] = self.owner
         if self.properties: body['properties'] = self.properties
         return body
@@ -7071,6 +7082,7 @@ class UpdateCatalog:
         if self.isolation_mode is not None: body['isolation_mode'] = self.isolation_mode
         if self.name is not None: body['name'] = self.name
         if self.new_name is not None: body['new_name'] = self.new_name
+        if self.options: body['options'] = self.options
         if self.owner is not None: body['owner'] = self.owner
         if self.properties: body['properties'] = self.properties
         return body
@@ -7084,6 +7096,7 @@ class UpdateCatalog:
                    isolation_mode=_enum(d, 'isolation_mode', CatalogIsolationMode),
                    name=d.get('name', None),
                    new_name=d.get('new_name', None),
+                   options=d.get('options', None),
                    owner=d.get('owner', None),
                    properties=d.get('properties', None))
 
@@ -8986,6 +8999,7 @@ class CatalogsAPI:
                enable_predictive_optimization: Optional[EnablePredictiveOptimization] = None,
                isolation_mode: Optional[CatalogIsolationMode] = None,
                new_name: Optional[str] = None,
+               options: Optional[Dict[str, str]] = None,
                owner: Optional[str] = None,
                properties: Optional[Dict[str, str]] = None) -> CatalogInfo:
         """Update a catalog.
@@ -9003,6 +9017,8 @@ class CatalogsAPI:
           Whether the current securable is accessible from all workspaces or a specific set of workspaces.
         :param new_name: str (optional)
           New name for the catalog.
+        :param options: Dict[str,str] (optional)
+          A map of key-value properties attached to the securable.
         :param owner: str (optional)
           Username of current owner of catalog.
         :param properties: Dict[str,str] (optional)
@@ -9016,6 +9032,7 @@ class CatalogsAPI:
             body['enable_predictive_optimization'] = enable_predictive_optimization.value
         if isolation_mode is not None: body['isolation_mode'] = isolation_mode.value
         if new_name is not None: body['new_name'] = new_name
+        if options is not None: body['options'] = options
         if owner is not None: body['owner'] = owner
         if properties is not None: body['properties'] = properties
         headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }

databricks/sdk/service/cleanrooms.py

@@ -1228,8 +1228,9 @@ class CleanRoomsAPI:
         
         Create a new clean room with the specified collaborators. This method is asynchronous; the returned
         name field inside the clean_room field can be used to poll the clean room status, using the
-        :method:cleanrooms/get method. When this method returns, the cluster will be in a PROVISIONING state.
-        The cluster will be usable once it enters an ACTIVE state.
+        :method:cleanrooms/get method. When this method returns, the clean room will be in a PROVISIONING
+        state, with only name, owner, comment, created_at and status populated. The clean room will be usable
+        once it enters an ACTIVE state.
         
         The caller must be a metastore admin or have the **CREATE_CLEAN_ROOM** privilege on the metastore.
         

databricks/sdk/service/dashboards.py

@@ -20,6 +20,66 @@ from databricks.sdk.service import sql
 # all definitions in this file are in alphabetical order
 
 
+@dataclass
+class CancelQueryExecutionResponse:
+    status: Optional[List[CancelQueryExecutionResponseStatus]] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the CancelQueryExecutionResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.status: body['status'] = [v.as_dict() for v in self.status]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CancelQueryExecutionResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.status: body['status'] = self.status
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> CancelQueryExecutionResponse:
+        """Deserializes the CancelQueryExecutionResponse from a dictionary."""
+        return cls(status=_repeated_dict(d, 'status', CancelQueryExecutionResponseStatus))
+
+
+@dataclass
+class CancelQueryExecutionResponseStatus:
+    data_token: str
+    """The token to poll for result asynchronously Example:
+    EC0A..ChAB7WCEn_4Qo4vkLqEbXsxxEgh3Y2pbWw45WhoQXgZSQo9aS5q2ZvFcbvbx9CgA-PAEAQ"""
+
+    pending: Optional[Empty] = None
+    """Represents an empty message, similar to google.protobuf.Empty, which is not available in the
+    firm right now."""
+
+    success: Optional[Empty] = None
+    """Represents an empty message, similar to google.protobuf.Empty, which is not available in the
+    firm right now."""
+
+    def as_dict(self) -> dict:
+        """Serializes the CancelQueryExecutionResponseStatus into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.data_token is not None: body['data_token'] = self.data_token
+        if self.pending: body['pending'] = self.pending.as_dict()
+        if self.success: body['success'] = self.success.as_dict()
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CancelQueryExecutionResponseStatus into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.data_token is not None: body['data_token'] = self.data_token
+        if self.pending: body['pending'] = self.pending
+        if self.success: body['success'] = self.success
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> CancelQueryExecutionResponseStatus:
+        """Deserializes the CancelQueryExecutionResponseStatus from a dictionary."""
+        return cls(data_token=d.get('data_token', None),
+                   pending=_from_dict(d, 'pending', Empty),
+                   success=_from_dict(d, 'success', Empty))
+
+
 @dataclass
 class CronSchedule:
     quartz_cron_expression: str
@@ -207,6 +267,87 @@ class DeleteSubscriptionResponse:
         return cls()
 
 
+@dataclass
+class Empty:
+    """Represents an empty message, similar to google.protobuf.Empty, which is not available in the
+    firm right now."""
+
+    def as_dict(self) -> dict:
+        """Serializes the Empty into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Empty into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> Empty:
+        """Deserializes the Empty from a dictionary."""
+        return cls()
+
+
+@dataclass
+class ExecutePublishedDashboardQueryRequest:
+    """Execute query request for published Dashboards. Since published dashboards have the option of
+    running as the publisher, the datasets, warehouse_id are excluded from the request and instead
+    read from the source (lakeview-config) via the additional parameters (dashboardName and
+    dashboardRevisionId)"""
+
+    dashboard_name: str
+    """Dashboard name and revision_id is required to retrieve PublishedDatasetDataModel which contains
+    the list of datasets, warehouse_id, and embedded_credentials"""
+
+    dashboard_revision_id: str
+
+    override_warehouse_id: Optional[str] = None
+    """A dashboard schedule can override the warehouse used as compute for processing the published
+    dashboard queries"""
+
+    def as_dict(self) -> dict:
+        """Serializes the ExecutePublishedDashboardQueryRequest into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.dashboard_name is not None: body['dashboard_name'] = self.dashboard_name
+        if self.dashboard_revision_id is not None: body['dashboard_revision_id'] = self.dashboard_revision_id
+        if self.override_warehouse_id is not None: body['override_warehouse_id'] = self.override_warehouse_id
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ExecutePublishedDashboardQueryRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.dashboard_name is not None: body['dashboard_name'] = self.dashboard_name
+        if self.dashboard_revision_id is not None: body['dashboard_revision_id'] = self.dashboard_revision_id
+        if self.override_warehouse_id is not None: body['override_warehouse_id'] = self.override_warehouse_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> ExecutePublishedDashboardQueryRequest:
+        """Deserializes the ExecutePublishedDashboardQueryRequest from a dictionary."""
+        return cls(dashboard_name=d.get('dashboard_name', None),
+                   dashboard_revision_id=d.get('dashboard_revision_id', None),
+                   override_warehouse_id=d.get('override_warehouse_id', None))
+
+
+@dataclass
+class ExecuteQueryResponse:
+
+    def as_dict(self) -> dict:
+        """Serializes the ExecuteQueryResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ExecuteQueryResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> ExecuteQueryResponse:
+        """Deserializes the ExecuteQueryResponse from a dictionary."""
+        return cls()
+
+
 @dataclass
 class GenieAttachment:
     """Genie AI Response"""
@@ -513,6 +654,25 @@ class GenieStartConversationResponse:
                    message_id=d.get('message_id', None))
 
 
+@dataclass
+class GetPublishedDashboardEmbeddedResponse:
+
+    def as_dict(self) -> dict:
+        """Serializes the GetPublishedDashboardEmbeddedResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GetPublishedDashboardEmbeddedResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> GetPublishedDashboardEmbeddedResponse:
+        """Deserializes the GetPublishedDashboardEmbeddedResponse from a dictionary."""
+        return cls()
+
+
 class LifecycleState(Enum):
 
     ACTIVE = 'ACTIVE'
@@ -747,6 +907,74 @@ class MigrateDashboardRequest:
                    update_parameter_syntax=d.get('update_parameter_syntax', None))
 
 
+@dataclass
+class PendingStatus:
+    data_token: str
+    """The token to poll for result asynchronously Example:
+    EC0A..ChAB7WCEn_4Qo4vkLqEbXsxxEgh3Y2pbWw45WhoQXgZSQo9aS5q2ZvFcbvbx9CgA-PAEAQ"""
+
+    def as_dict(self) -> dict:
+        """Serializes the PendingStatus into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.data_token is not None: body['data_token'] = self.data_token
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PendingStatus into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.data_token is not None: body['data_token'] = self.data_token
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> PendingStatus:
+        """Deserializes the PendingStatus from a dictionary."""
+        return cls(data_token=d.get('data_token', None))
+
+
+@dataclass
+class PollQueryStatusResponse:
+    data: Optional[List[PollQueryStatusResponseData]] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the PollQueryStatusResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.data: body['data'] = [v.as_dict() for v in self.data]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PollQueryStatusResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.data: body['data'] = self.data
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> PollQueryStatusResponse:
+        """Deserializes the PollQueryStatusResponse from a dictionary."""
+        return cls(data=_repeated_dict(d, 'data', PollQueryStatusResponseData))
+
+
+@dataclass
+class PollQueryStatusResponseData:
+    status: QueryResponseStatus
+
+    def as_dict(self) -> dict:
+        """Serializes the PollQueryStatusResponseData into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.status: body['status'] = self.status.as_dict()
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PollQueryStatusResponseData into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.status: body['status'] = self.status
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> PollQueryStatusResponseData:
+        """Deserializes the PollQueryStatusResponseData from a dictionary."""
+        return cls(status=_from_dict(d, 'status', QueryResponseStatus))
+
+
 @dataclass
 class PublishRequest:
     dashboard_id: Optional[str] = None
@@ -895,6 +1123,55 @@ class QueryAttachment:
                    title=d.get('title', None))
 
 
+@dataclass
+class QueryResponseStatus:
+    canceled: Optional[Empty] = None
+    """Represents an empty message, similar to google.protobuf.Empty, which is not available in the
+    firm right now."""
+
+    closed: Optional[Empty] = None
+    """Represents an empty message, similar to google.protobuf.Empty, which is not available in the
+    firm right now."""
+
+    pending: Optional[PendingStatus] = None
+
+    statement_id: Optional[str] = None
+    """The statement id in format(01eef5da-c56e-1f36-bafa-21906587d6ba) The statement_id should be
+    identical to data_token in SuccessStatus and PendingStatus. This field is created for audit
+    logging purpose to record the statement_id of all QueryResponseStatus."""
+
+    success: Optional[SuccessStatus] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the QueryResponseStatus into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.canceled: body['canceled'] = self.canceled.as_dict()
+        if self.closed: body['closed'] = self.closed.as_dict()
+        if self.pending: body['pending'] = self.pending.as_dict()
+        if self.statement_id is not None: body['statement_id'] = self.statement_id
+        if self.success: body['success'] = self.success.as_dict()
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the QueryResponseStatus into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.canceled: body['canceled'] = self.canceled
+        if self.closed: body['closed'] = self.closed
+        if self.pending: body['pending'] = self.pending
+        if self.statement_id is not None: body['statement_id'] = self.statement_id
+        if self.success: body['success'] = self.success
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> QueryResponseStatus:
+        """Deserializes the QueryResponseStatus from a dictionary."""
+        return cls(canceled=_from_dict(d, 'canceled', Empty),
+                   closed=_from_dict(d, 'closed', Empty),
+                   pending=_from_dict(d, 'pending', PendingStatus),
+                   statement_id=d.get('statement_id', None),
+                   success=_from_dict(d, 'success', SuccessStatus))
+
+
 @dataclass
 class QuerySchema:
     columns: Optional[List[QuerySchemaColumn]] = None
@@ -1218,6 +1495,35 @@ class SubscriptionSubscriberUser:
         return cls(user_id=d.get('user_id', None))
 
 
+@dataclass
+class SuccessStatus:
+    data_token: str
+    """The token to poll for result asynchronously Example:
+    EC0A..ChAB7WCEn_4Qo4vkLqEbXsxxEgh3Y2pbWw45WhoQXgZSQo9aS5q2ZvFcbvbx9CgA-PAEAQ"""
+
+    truncated: Optional[bool] = None
+    """Whether the query result is truncated (either by byte limit or row limit)"""
+
+    def as_dict(self) -> dict:
+        """Serializes the SuccessStatus into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.data_token is not None: body['data_token'] = self.data_token
+        if self.truncated is not None: body['truncated'] = self.truncated
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the SuccessStatus into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.data_token is not None: body['data_token'] = self.data_token
+        if self.truncated is not None: body['truncated'] = self.truncated
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> SuccessStatus:
+        """Deserializes the SuccessStatus from a dictionary."""
+        return cls(data_token=d.get('data_token', None), truncated=d.get('truncated', None))
+
+
 @dataclass
 class TextAttachment:
     content: Optional[str] = None
@@ -1907,3 +2213,107 @@ class LakeviewAPI:
                            body=body,
                            headers=headers)
         return Schedule.from_dict(res)
+
+
+class LakeviewEmbeddedAPI:
+    """Token-based Lakeview APIs for embedding dashboards in external applications."""
+
+    def __init__(self, api_client):
+        self._api = api_client
+
+    def get_published_dashboard_embedded(self, dashboard_id: str):
+        """Read a published dashboard in an embedded ui.
+        
+        Get the current published dashboard within an embedded context.
+        
+        :param dashboard_id: str
+          UUID identifying the published dashboard.
+        
+        
+        """
+
+        headers = {'Accept': 'application/json', }
+
+        self._api.do('GET',
+                     f'/api/2.0/lakeview/dashboards/{dashboard_id}/published/embedded',
+                     headers=headers)
+
+
+class QueryExecutionAPI:
+    """Query execution APIs for AI / BI Dashboards"""
+
+    def __init__(self, api_client):
+        self._api = api_client
+
+    def cancel_published_query_execution(self,
+                                         dashboard_name: str,
+                                         dashboard_revision_id: str,
+                                         *,
+                                         tokens: Optional[List[str]] = None) -> CancelQueryExecutionResponse:
+        """Cancel the results for the a query for a published, embedded dashboard.
+        
+        :param dashboard_name: str
+        :param dashboard_revision_id: str
+        :param tokens: List[str] (optional)
+          Example: EC0A..ChAB7WCEn_4Qo4vkLqEbXsxxEgh3Y2pbWw45WhoQXgZSQo9aS5q2ZvFcbvbx9CgA-PAEAQ
+        
+        :returns: :class:`CancelQueryExecutionResponse`
+        """
+
+        query = {}
+        if dashboard_name is not None: query['dashboard_name'] = dashboard_name
+        if dashboard_revision_id is not None: query['dashboard_revision_id'] = dashboard_revision_id
+        if tokens is not None: query['tokens'] = [v for v in tokens]
+        headers = {'Accept': 'application/json', }
+
+        res = self._api.do('DELETE', '/api/2.0/lakeview-query/query/published', query=query, headers=headers)
+        return CancelQueryExecutionResponse.from_dict(res)
+
+    def execute_published_dashboard_query(self,
+                                          dashboard_name: str,
+                                          dashboard_revision_id: str,
+                                          *,
+                                          override_warehouse_id: Optional[str] = None):
+        """Execute a query for a published dashboard.
+        
+        :param dashboard_name: str
+          Dashboard name and revision_id is required to retrieve PublishedDatasetDataModel which contains the
+          list of datasets, warehouse_id, and embedded_credentials
+        :param dashboard_revision_id: str
+        :param override_warehouse_id: str (optional)
+          A dashboard schedule can override the warehouse used as compute for processing the published
+          dashboard queries
+        
+        
+        """
+        body = {}
+        if dashboard_name is not None: body['dashboard_name'] = dashboard_name
+        if dashboard_revision_id is not None: body['dashboard_revision_id'] = dashboard_revision_id
+        if override_warehouse_id is not None: body['override_warehouse_id'] = override_warehouse_id
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+
+        self._api.do('POST', '/api/2.0/lakeview-query/query/published', body=body, headers=headers)
+
+    def poll_published_query_status(self,
+                                    dashboard_name: str,
+                                    dashboard_revision_id: str,
+                                    *,
+                                    tokens: Optional[List[str]] = None) -> PollQueryStatusResponse:
+        """Poll the results for the a query for a published, embedded dashboard.
+        
+        :param dashboard_name: str
+        :param dashboard_revision_id: str
+        :param tokens: List[str] (optional)
+          Example: EC0A..ChAB7WCEn_4Qo4vkLqEbXsxxEgh3Y2pbWw45WhoQXgZSQo9aS5q2ZvFcbvbx9CgA-PAEAQ
+        
+        :returns: :class:`PollQueryStatusResponse`
+        """
+
+        query = {}
+        if dashboard_name is not None: query['dashboard_name'] = dashboard_name
+        if dashboard_revision_id is not None: query['dashboard_revision_id'] = dashboard_revision_id
+        if tokens is not None: query['tokens'] = [v for v in tokens]
+        headers = {'Accept': 'application/json', }
+
+        res = self._api.do('GET', '/api/2.0/lakeview-query/query/published', query=query, headers=headers)
+        return PollQueryStatusResponse.from_dict(res)

databricks/sdk/service/jobs.py

@@ -4915,6 +4915,10 @@ class RunTask:
     description: Optional[str] = None
     """An optional description for this task."""
 
+    disabled: Optional[bool] = None
+    """Denotes whether or not the task was disabled by the user. Disabled tasks do not execute and are
+    immediately skipped as soon as they are unblocked."""
+
     effective_performance_target: Optional[PerformanceTarget] = None
     """effective_performance_target is the actual performance target used by the run during execution.
     effective_performance_target can differ from performance_target depending on if the job was
@@ -5069,6 +5073,7 @@ class RunTask:
         if self.dbt_task: body['dbt_task'] = self.dbt_task.as_dict()
         if self.depends_on: body['depends_on'] = [v.as_dict() for v in self.depends_on]
         if self.description is not None: body['description'] = self.description
+        if self.disabled is not None: body['disabled'] = self.disabled
         if self.effective_performance_target is not None:
             body['effective_performance_target'] = self.effective_performance_target.value
         if self.email_notifications: body['email_notifications'] = self.email_notifications.as_dict()
@@ -5116,6 +5121,7 @@ class RunTask:
         if self.dbt_task: body['dbt_task'] = self.dbt_task
         if self.depends_on: body['depends_on'] = self.depends_on
         if self.description is not None: body['description'] = self.description
+        if self.disabled is not None: body['disabled'] = self.disabled
         if self.effective_performance_target is not None:
             body['effective_performance_target'] = self.effective_performance_target
         if self.email_notifications: body['email_notifications'] = self.email_notifications
@@ -5164,6 +5170,7 @@ class RunTask:
                    dbt_task=_from_dict(d, 'dbt_task', DbtTask),
                    depends_on=_repeated_dict(d, 'depends_on', TaskDependency),
                    description=d.get('description', None),
+                   disabled=d.get('disabled', None),
                    effective_performance_target=_enum(d, 'effective_performance_target', PerformanceTarget),
                    email_notifications=_from_dict(d, 'email_notifications', JobEmailNotifications),
                    end_time=d.get('end_time', None),