databricks-sdk 0.18.0__py3-none-any.whl → 0.19.0__py3-none-any.whl

databricks/sdk/service/jobs.py

@@ -676,13 +676,22 @@ class DbtTask:
     specified. If no warehouse_id is specified and this folder is unset, the root directory is used."""
 
     project_directory: Optional[str] = None
-    """Optional (relative) path to the project directory, if no value is provided, the root of the git
-    repository is used."""
+    """Path to the project directory. Optional for Git sourced tasks, in which case if no value is
+    provided, the root of the Git repository is used."""
 
     schema: Optional[str] = None
     """Optional schema to write to. This parameter is only used when a warehouse_id is also provided.
     If not provided, the `default` schema is used."""
 
+    source: Optional[Source] = None
+    """Optional location type of the project directory. When set to `WORKSPACE`, the project will be
+    retrieved from the local <Databricks> workspace. When set to `GIT`, the project will be
+    retrieved from a Git repository defined in `git_source`. If the value is empty, the task will
+    use `GIT` if `git_source` is defined and `WORKSPACE` otherwise.
+    
+    * `WORKSPACE`: Project is located in <Databricks> workspace. * `GIT`: Project is located in
+    cloud Git provider."""
+
     warehouse_id: Optional[str] = None
     """ID of the SQL warehouse to connect to. If provided, we automatically generate and provide the
     profile and connection details to dbt. It can be overridden on a per-command basis by using the
@@ -696,6 +705,7 @@ class DbtTask:
         if self.profiles_directory is not None: body['profiles_directory'] = self.profiles_directory
         if self.project_directory is not None: body['project_directory'] = self.project_directory
         if self.schema is not None: body['schema'] = self.schema
+        if self.source is not None: body['source'] = self.source.value
         if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
         return body
 
@@ -707,6 +717,7 @@ class DbtTask:
                    profiles_directory=d.get('profiles_directory', None),
                    project_directory=d.get('project_directory', None),
                    schema=d.get('schema', None),
+                   source=_enum(d, 'source', Source),
                    warehouse_id=d.get('warehouse_id', None))
 
 
@@ -771,8 +782,8 @@ class FileArrivalTriggerConfiguration:
     time the trigger fired. The minimum allowed value is 60 seconds"""
 
     url: Optional[str] = None
-    """URL to be monitored for file arrivals. The path must point to the root or a subpath of the
-    external location."""
+    """The storage location to monitor for file arrivals. The value must point to the root or a subpath
+    of an external location URL or the root or subpath of a Unity Catalog volume."""
 
     wait_after_last_change_seconds: Optional[int] = None
     """If set, the trigger starts a run only after no file activity has occurred for the specified
@@ -797,6 +808,117 @@ class FileArrivalTriggerConfiguration:
                    wait_after_last_change_seconds=d.get('wait_after_last_change_seconds', None))
 
 
+@dataclass
+class ForEachStats:
+    error_message_stats: Optional[ForEachTaskErrorMessageStats] = None
+    """Sample of 3 most common error messages occurred during the iteration."""
+
+    task_run_stats: Optional[ForEachTaskTaskRunStats] = None
+    """Describes stats of the iteration. Only latest retries are considered."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ForEachStats into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.error_message_stats: body['error_message_stats'] = self.error_message_stats.as_dict()
+        if self.task_run_stats: body['task_run_stats'] = self.task_run_stats.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> ForEachStats:
+        """Deserializes the ForEachStats from a dictionary."""
+        return cls(error_message_stats=_from_dict(d, 'error_message_stats', ForEachTaskErrorMessageStats),
+                   task_run_stats=_from_dict(d, 'task_run_stats', ForEachTaskTaskRunStats))
+
+
+@dataclass
+class ForEachTask:
+    inputs: str
+    """Array for task to iterate on. This can be a JSON string or a reference to an array parameter."""
+
+    task: Task
+
+    concurrency: Optional[int] = None
+    """Controls the number of active iterations task runs. Default is 100 (maximal value)."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ForEachTask into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.concurrency is not None: body['concurrency'] = self.concurrency
+        if self.inputs is not None: body['inputs'] = self.inputs
+        if self.task: body['task'] = self.task.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> ForEachTask:
+        """Deserializes the ForEachTask from a dictionary."""
+        return cls(concurrency=d.get('concurrency', None),
+                   inputs=d.get('inputs', None),
+                   task=_from_dict(d, 'task', Task))
+
+
+@dataclass
+class ForEachTaskErrorMessageStats:
+    count: Optional[str] = None
+    """Describes the count of such error message encountered during the iterations."""
+
+    error_message: Optional[str] = None
+    """Describes the error message occured during the iterations."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ForEachTaskErrorMessageStats into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.count is not None: body['count'] = self.count
+        if self.error_message is not None: body['error_message'] = self.error_message
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> ForEachTaskErrorMessageStats:
+        """Deserializes the ForEachTaskErrorMessageStats from a dictionary."""
+        return cls(count=d.get('count', None), error_message=d.get('error_message', None))
+
+
+@dataclass
+class ForEachTaskTaskRunStats:
+    active_iterations: Optional[int] = None
+    """Describes the iteration runs having an active lifecycle state or an active run sub state."""
+
+    completed_iterations: Optional[int] = None
+    """Describes the number of failed and succeeded iteration runs."""
+
+    failed_iterations: Optional[int] = None
+    """Describes the number of failed iteration runs."""
+
+    scheduled_iterations: Optional[int] = None
+    """Describes the number of iteration runs that have been scheduled."""
+
+    succeeded_iterations: Optional[int] = None
+    """Describes the number of succeeded iteration runs."""
+
+    total_iterations: Optional[int] = None
+    """Describes the length of the list of items to iterate over."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ForEachTaskTaskRunStats into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.active_iterations is not None: body['active_iterations'] = self.active_iterations
+        if self.completed_iterations is not None: body['completed_iterations'] = self.completed_iterations
+        if self.failed_iterations is not None: body['failed_iterations'] = self.failed_iterations
+        if self.scheduled_iterations is not None: body['scheduled_iterations'] = self.scheduled_iterations
+        if self.succeeded_iterations is not None: body['succeeded_iterations'] = self.succeeded_iterations
+        if self.total_iterations is not None: body['total_iterations'] = self.total_iterations
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> ForEachTaskTaskRunStats:
+        """Deserializes the ForEachTaskTaskRunStats from a dictionary."""
+        return cls(active_iterations=d.get('active_iterations', None),
+                   completed_iterations=d.get('completed_iterations', None),
+                   failed_iterations=d.get('failed_iterations', None),
+                   scheduled_iterations=d.get('scheduled_iterations', None),
+                   succeeded_iterations=d.get('succeeded_iterations', None),
+                   total_iterations=d.get('total_iterations', None))
+
+
 class Format(Enum):
 
     MULTI_TASK = 'MULTI_TASK'
@@ -2531,6 +2653,36 @@ class RunConditionTaskOp(Enum):
     NOT_EQUAL = 'NOT_EQUAL'
 
 
+@dataclass
+class RunForEachTask:
+    concurrency: Optional[int] = None
+    """Controls the number of active iterations task runs. Default is 100 (maximal value)."""
+
+    inputs: Optional[str] = None
+    """Array for task to iterate on. This can be a JSON string or a reference to an array parameter."""
+
+    stats: Optional[ForEachStats] = None
+
+    task: Optional[Task] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the RunForEachTask into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.concurrency is not None: body['concurrency'] = self.concurrency
+        if self.inputs is not None: body['inputs'] = self.inputs
+        if self.stats: body['stats'] = self.stats.as_dict()
+        if self.task: body['task'] = self.task.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> RunForEachTask:
+        """Deserializes the RunForEachTask from a dictionary."""
+        return cls(concurrency=d.get('concurrency', None),
+                   inputs=d.get('inputs', None),
+                   stats=_from_dict(d, 'stats', ForEachStats),
+                   task=_from_dict(d, 'task', Task))
+
+
 class RunIf(Enum):
     """An optional value indicating the condition that determines whether the task should be run once
     its dependencies have been completed. When omitted, defaults to `ALL_SUCCESS`.
@@ -3056,6 +3208,9 @@ class RunTask:
     When running jobs on an existing cluster, you may need to manually restart the cluster if it
     stops responding. We suggest running jobs on new clusters for greater reliability."""
 
+    for_each_task: Optional[RunForEachTask] = None
+    """If for_each_task, indicates that this task must execute the nested task within it."""
+
     git_source: Optional[GitSource] = None
     """An optional specification for a remote Git repository containing the source code used by tasks.
     Version-controlled source code is supported by notebook, dbt, Python script, and SQL File tasks.
@@ -3159,6 +3314,7 @@ class RunTask:
         if self.end_time is not None: body['end_time'] = self.end_time
         if self.execution_duration is not None: body['execution_duration'] = self.execution_duration
         if self.existing_cluster_id is not None: body['existing_cluster_id'] = self.existing_cluster_id
+        if self.for_each_task: body['for_each_task'] = self.for_each_task.as_dict()
         if self.git_source: body['git_source'] = self.git_source.as_dict()
         if self.libraries: body['libraries'] = [v.as_dict() for v in self.libraries]
         if self.new_cluster: body['new_cluster'] = self.new_cluster.as_dict()
@@ -3193,6 +3349,7 @@ class RunTask:
                    end_time=d.get('end_time', None),
                    execution_duration=d.get('execution_duration', None),
                    existing_cluster_id=d.get('existing_cluster_id', None),
+                   for_each_task=_from_dict(d, 'for_each_task', RunForEachTask),
                    git_source=_from_dict(d, 'git_source', GitSource),
                    libraries=_repeated_dict(d, 'libraries', compute.Library),
                    new_cluster=_from_dict(d, 'new_cluster', compute.ClusterSpec),
@@ -3662,18 +3819,29 @@ class SqlTaskDashboard:
 @dataclass
 class SqlTaskFile:
     path: str
-    """Relative path of the SQL file in the remote Git repository."""
+    """Path of the SQL file. Must be relative if the source is a remote Git repository and absolute for
+    workspace paths."""
+
+    source: Optional[Source] = None
+    """Optional location type of the SQL file. When set to `WORKSPACE`, the SQL file will be retrieved
+    from the local <Databricks> workspace. When set to `GIT`, the SQL file will be retrieved from a
+    Git repository defined in `git_source`. If the value is empty, the task will use `GIT` if
+    `git_source` is defined and `WORKSPACE` otherwise.
+    
+    * `WORKSPACE`: SQL file is located in <Databricks> workspace. * `GIT`: SQL file is located in
+    cloud Git provider."""
 
     def as_dict(self) -> dict:
         """Serializes the SqlTaskFile into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.path is not None: body['path'] = self.path
+        if self.source is not None: body['source'] = self.source.value
         return body
 
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> SqlTaskFile:
         """Deserializes the SqlTaskFile from a dictionary."""
-        return cls(path=d.get('path', None))
+        return cls(path=d.get('path', None), source=_enum(d, 'source', Source))
 
 
 @dataclass
@@ -3847,6 +4015,10 @@ class SubmitTask:
     to manually restart the cluster if it stops responding. We suggest running jobs on new clusters
     for greater reliability."""
 
+    for_each_task: Optional[ForEachTask] = None
+    """If for_each_task, indicates that this must execute the nested task within it for the inputs
+    provided."""
+
     health: Optional[JobsHealthRules] = None
     """An optional set of health rules that can be defined for this job."""
 
@@ -3920,6 +4092,7 @@ class SubmitTask:
         if self.depends_on: body['depends_on'] = [v.as_dict() for v in self.depends_on]
         if self.email_notifications: body['email_notifications'] = self.email_notifications.as_dict()
         if self.existing_cluster_id is not None: body['existing_cluster_id'] = self.existing_cluster_id
+        if self.for_each_task: body['for_each_task'] = self.for_each_task.as_dict()
         if self.health: body['health'] = self.health.as_dict()
         if self.libraries: body['libraries'] = [v.as_dict() for v in self.libraries]
         if self.new_cluster: body['new_cluster'] = self.new_cluster.as_dict()
@@ -3945,6 +4118,7 @@ class SubmitTask:
                    depends_on=_repeated_dict(d, 'depends_on', TaskDependency),
                    email_notifications=_from_dict(d, 'email_notifications', JobEmailNotifications),
                    existing_cluster_id=d.get('existing_cluster_id', None),
+                   for_each_task=_from_dict(d, 'for_each_task', ForEachTask),
                    health=_from_dict(d, 'health', JobsHealthRules),
                    libraries=_repeated_dict(d, 'libraries', compute.Library),
                    new_cluster=_from_dict(d, 'new_cluster', compute.ClusterSpec),
@@ -4002,6 +4176,10 @@ class Task:
     to manually restart the cluster if it stops responding. We suggest running jobs on new clusters
     for greater reliability."""
 
+    for_each_task: Optional[ForEachTask] = None
+    """If for_each_task, indicates that this must execute the nested task within it for the inputs
+    provided."""
+
     health: Optional[JobsHealthRules] = None
     """An optional set of health rules that can be defined for this job."""
 
@@ -4098,6 +4276,7 @@ class Task:
         if self.description is not None: body['description'] = self.description
         if self.email_notifications: body['email_notifications'] = self.email_notifications.as_dict()
         if self.existing_cluster_id is not None: body['existing_cluster_id'] = self.existing_cluster_id
+        if self.for_each_task: body['for_each_task'] = self.for_each_task.as_dict()
         if self.health: body['health'] = self.health.as_dict()
         if self.job_cluster_key is not None: body['job_cluster_key'] = self.job_cluster_key
         if self.libraries: body['libraries'] = [v.as_dict() for v in self.libraries]
@@ -4131,6 +4310,7 @@ class Task:
                    description=d.get('description', None),
                    email_notifications=_from_dict(d, 'email_notifications', TaskEmailNotifications),
                    existing_cluster_id=d.get('existing_cluster_id', None),
+                   for_each_task=_from_dict(d, 'for_each_task', ForEachTask),
                    health=_from_dict(d, 'health', JobsHealthRules),
                    job_cluster_key=d.get('job_cluster_key', None),
                    libraries=_repeated_dict(d, 'libraries', compute.Library),
@@ -4945,10 +5125,9 @@ class JobsAPI:
 
         while True:
             json = self._api.do('GET', '/api/2.1/jobs/list', query=query, headers=headers)
-            if 'jobs' not in json or not json['jobs']:
-                return
-            for v in json['jobs']:
-                yield BaseJob.from_dict(v)
+            if 'jobs' in json:
+                for v in json['jobs']:
+                    yield BaseJob.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             query['page_token'] = json['next_page_token']
@@ -5017,10 +5196,9 @@ class JobsAPI:
 
         while True:
             json = self._api.do('GET', '/api/2.1/jobs/runs/list', query=query, headers=headers)
-            if 'runs' not in json or not json['runs']:
-                return
-            for v in json['runs']:
-                yield BaseRun.from_dict(v)
+            if 'runs' in json:
+                for v in json['runs']:
+                    yield BaseRun.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             query['page_token'] = json['next_page_token']

databricks/sdk/service/ml.py

@@ -3710,10 +3710,9 @@ class ExperimentsAPI:
 
         while True:
             json = self._api.do('GET', '/api/2.0/mlflow/metrics/get-history', query=query, headers=headers)
-            if 'metrics' not in json or not json['metrics']:
-                return
-            for v in json['metrics']:
-                yield Metric.from_dict(v)
+            if 'metrics' in json:
+                for v in json['metrics']:
+                    yield Metric.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             query['page_token'] = json['next_page_token']
@@ -3807,10 +3806,9 @@ class ExperimentsAPI:
 
         while True:
             json = self._api.do('GET', '/api/2.0/mlflow/artifacts/list', query=query, headers=headers)
-            if 'files' not in json or not json['files']:
-                return
-            for v in json['files']:
-                yield FileInfo.from_dict(v)
+            if 'files' in json:
+                for v in json['files']:
+                    yield FileInfo.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             query['page_token'] = json['next_page_token']
@@ -3844,10 +3842,9 @@ class ExperimentsAPI:
 
         while True:
             json = self._api.do('GET', '/api/2.0/mlflow/experiments/list', query=query, headers=headers)
-            if 'experiments' not in json or not json['experiments']:
-                return
-            for v in json['experiments']:
-                yield Experiment.from_dict(v)
+            if 'experiments' in json:
+                for v in json['experiments']:
+                    yield Experiment.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             query['page_token'] = json['next_page_token']
@@ -4125,10 +4122,9 @@ class ExperimentsAPI:
 
         while True:
             json = self._api.do('POST', '/api/2.0/mlflow/experiments/search', body=body, headers=headers)
-            if 'experiments' not in json or not json['experiments']:
-                return
-            for v in json['experiments']:
-                yield Experiment.from_dict(v)
+            if 'experiments' in json:
+                for v in json['experiments']:
+                    yield Experiment.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             body['page_token'] = json['next_page_token']
@@ -4186,10 +4182,9 @@ class ExperimentsAPI:
 
         while True:
             json = self._api.do('POST', '/api/2.0/mlflow/runs/search', body=body, headers=headers)
-            if 'runs' not in json or not json['runs']:
-                return
-            for v in json['runs']:
-                yield Run.from_dict(v)
+            if 'runs' in json:
+                for v in json['runs']:
+                    yield Run.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             body['page_token'] = json['next_page_token']
@@ -4903,10 +4898,9 @@ class ModelRegistryAPI:
 
         while True:
             json = self._api.do('GET', '/api/2.0/mlflow/registered-models/list', query=query, headers=headers)
-            if 'registered_models' not in json or not json['registered_models']:
-                return
-            for v in json['registered_models']:
-                yield Model.from_dict(v)
+            if 'registered_models' in json:
+                for v in json['registered_models']:
+                    yield Model.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             query['page_token'] = json['next_page_token']
@@ -4963,10 +4957,9 @@ class ModelRegistryAPI:
 
         while True:
             json = self._api.do('GET', '/api/2.0/mlflow/registry-webhooks/list', query=query, headers=headers)
-            if 'webhooks' not in json or not json['webhooks']:
-                return
-            for v in json['webhooks']:
-                yield RegistryWebhook.from_dict(v)
+            if 'webhooks' in json:
+                for v in json['webhooks']:
+                    yield RegistryWebhook.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             query['page_token'] = json['next_page_token']
@@ -5062,10 +5055,9 @@ class ModelRegistryAPI:
 
         while True:
             json = self._api.do('GET', '/api/2.0/mlflow/model-versions/search', query=query, headers=headers)
-            if 'model_versions' not in json or not json['model_versions']:
-                return
-            for v in json['model_versions']:
-                yield ModelVersion.from_dict(v)
+            if 'model_versions' in json:
+                for v in json['model_versions']:
+                    yield ModelVersion.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             query['page_token'] = json['next_page_token']
@@ -5108,10 +5100,9 @@ class ModelRegistryAPI:
                                 '/api/2.0/mlflow/registered-models/search',
                                 query=query,
                                 headers=headers)
-            if 'registered_models' not in json or not json['registered_models']:
-                return
-            for v in json['registered_models']:
-                yield Model.from_dict(v)
+            if 'registered_models' in json:
+                for v in json['registered_models']:
+                    yield Model.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             query['page_token'] = json['next_page_token']

databricks/sdk/service/oauth2.py

@@ -629,10 +629,9 @@ class OAuthPublishedAppsAPI:
                                 f'/api/2.0/accounts/{self._api.account_id}/oauth2/published-apps/',
                                 query=query,
                                 headers=headers)
-            if 'apps' not in json or not json['apps']:
-                return
-            for v in json['apps']:
-                yield PublishedAppOutput.from_dict(v)
+            if 'apps' in json:
+                for v in json['apps']:
+                    yield PublishedAppOutput.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             query['page_token'] = json['next_page_token']

databricks/sdk/service/pipelines.py

@@ -791,7 +791,7 @@ class PipelineCluster:
     apply_policy_default_values: Optional[bool] = None
     """Note: This field won't be persisted. Only API users will check this field."""
 
-    autoscale: Optional[compute.AutoScale] = None
+    autoscale: Optional[PipelineClusterAutoscale] = None
     """Parameters needed in order to automatically scale clusters up and down based on load. Note:
     autoscaling works best with DB runtime versions 3.0 or later."""
 
@@ -914,7 +914,7 @@ class PipelineCluster:
     def from_dict(cls, d: Dict[str, any]) -> PipelineCluster:
         """Deserializes the PipelineCluster from a dictionary."""
         return cls(apply_policy_default_values=d.get('apply_policy_default_values', None),
-                   autoscale=_from_dict(d, 'autoscale', compute.AutoScale),
+                   autoscale=_from_dict(d, 'autoscale', PipelineClusterAutoscale),
                    aws_attributes=_from_dict(d, 'aws_attributes', compute.AwsAttributes),
                    azure_attributes=_from_dict(d, 'azure_attributes', compute.AzureAttributes),
                    cluster_log_conf=_from_dict(d, 'cluster_log_conf', compute.ClusterLogConf),
@@ -933,6 +933,48 @@ class PipelineCluster:
                    ssh_public_keys=d.get('ssh_public_keys', None))
 
 
+@dataclass
+class PipelineClusterAutoscale:
+    min_workers: int
+    """The minimum number of workers the cluster can scale down to when underutilized. It is also the
+    initial number of workers the cluster will have after creation."""
+
+    max_workers: int
+    """The maximum number of workers to which the cluster can scale up when overloaded. `max_workers`
+    must be strictly greater than `min_workers`."""
+
+    mode: Optional[PipelineClusterAutoscaleMode] = None
+    """Databricks Enhanced Autoscaling optimizes cluster utilization by automatically allocating
+    cluster resources based on workload volume, with minimal impact to the data processing latency
+    of your pipelines. Enhanced Autoscaling is available for `updates` clusters only. The legacy
+    autoscaling feature is used for `maintenance` clusters."""
+
+    def as_dict(self) -> dict:
+        """Serializes the PipelineClusterAutoscale into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.max_workers is not None: body['max_workers'] = self.max_workers
+        if self.min_workers is not None: body['min_workers'] = self.min_workers
+        if self.mode is not None: body['mode'] = self.mode.value
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> PipelineClusterAutoscale:
+        """Deserializes the PipelineClusterAutoscale from a dictionary."""
+        return cls(max_workers=d.get('max_workers', None),
+                   min_workers=d.get('min_workers', None),
+                   mode=_enum(d, 'mode', PipelineClusterAutoscaleMode))
+
+
+class PipelineClusterAutoscaleMode(Enum):
+    """Databricks Enhanced Autoscaling optimizes cluster utilization by automatically allocating
+    cluster resources based on workload volume, with minimal impact to the data processing latency
+    of your pipelines. Enhanced Autoscaling is available for `updates` clusters only. The legacy
+    autoscaling feature is used for `maintenance` clusters."""
+
+    ENHANCED = 'ENHANCED'
+    LEGACY = 'LEGACY'
+
+
 @dataclass
 class PipelineEvent:
     error: Optional[ErrorDetail] = None
@@ -1891,10 +1933,9 @@ class PipelinesAPI:
                                 f'/api/2.0/pipelines/{pipeline_id}/events',
                                 query=query,
                                 headers=headers)
-            if 'events' not in json or not json['events']:
-                return
-            for v in json['events']:
-                yield PipelineEvent.from_dict(v)
+            if 'events' in json:
+                for v in json['events']:
+                    yield PipelineEvent.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             query['page_token'] = json['next_page_token']
@@ -1940,10 +1981,9 @@ class PipelinesAPI:
 
         while True:
             json = self._api.do('GET', '/api/2.0/pipelines', query=query, headers=headers)
-            if 'statuses' not in json or not json['statuses']:
-                return
-            for v in json['statuses']:
-                yield PipelineStateInfo.from_dict(v)
+            if 'statuses' in json:
+                for v in json['statuses']:
+                    yield PipelineStateInfo.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             query['page_token'] = json['next_page_token']
@@ -1978,25 +2018,6 @@ class PipelinesAPI:
         res = self._api.do('GET', f'/api/2.0/pipelines/{pipeline_id}/updates', query=query, headers=headers)
         return ListUpdatesResponse.from_dict(res)
 
-    def reset(self, pipeline_id: str) -> Wait[GetPipelineResponse]:
-        """Reset a pipeline.
-        
-        Resets a pipeline.
-        
-        :param pipeline_id: str
-        
-        :returns:
-          Long-running operation waiter for :class:`GetPipelineResponse`.
-          See :method:wait_get_pipeline_running for more details.
-        """
-
-        headers = {'Accept': 'application/json', }
-        self._api.do('POST', f'/api/2.0/pipelines/{pipeline_id}/reset', headers=headers)
-        return Wait(self.wait_get_pipeline_running, pipeline_id=pipeline_id)
-
-    def reset_and_wait(self, pipeline_id: str, timeout=timedelta(minutes=20)) -> GetPipelineResponse:
-        return self.reset(pipeline_id=pipeline_id).result(timeout=timeout)
-
     def set_permissions(
             self,
             pipeline_id: str,