databricks-sdk 0.58.0__py3-none-any.whl → 0.60.0__py3-none-any.whl

databricks/sdk/service/dashboards.py

@@ -413,49 +413,6 @@ class GenieConversationSummary:
         )
 
 
-@dataclass
-class GenieCreateConversationMessageRequest:
-    content: str
-    """User message content."""
-
-    conversation_id: Optional[str] = None
-    """The ID associated with the conversation."""
-
-    space_id: Optional[str] = None
-    """The ID associated with the Genie space where the conversation is started."""
-
-    def as_dict(self) -> dict:
-        """Serializes the GenieCreateConversationMessageRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.content is not None:
-            body["content"] = self.content
-        if self.conversation_id is not None:
-            body["conversation_id"] = self.conversation_id
-        if self.space_id is not None:
-            body["space_id"] = self.space_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the GenieCreateConversationMessageRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.content is not None:
-            body["content"] = self.content
-        if self.conversation_id is not None:
-            body["conversation_id"] = self.conversation_id
-        if self.space_id is not None:
-            body["space_id"] = self.space_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> GenieCreateConversationMessageRequest:
-        """Deserializes the GenieCreateConversationMessageRequest from a dictionary."""
-        return cls(
-            content=d.get("content", None),
-            conversation_id=d.get("conversation_id", None),
-            space_id=d.get("space_id", None),
-        )
-
-
 @dataclass
 class GenieGetMessageQueryResultResponse:
     statement_response: Optional[sql.StatementResponse] = None
@@ -810,38 +767,6 @@ class GenieSpace:
         return cls(description=d.get("description", None), space_id=d.get("space_id", None), title=d.get("title", None))
 
 
-@dataclass
-class GenieStartConversationMessageRequest:
-    content: str
-    """The text of the message that starts the conversation."""
-
-    space_id: Optional[str] = None
-    """The ID associated with the Genie space where you want to start a conversation."""
-
-    def as_dict(self) -> dict:
-        """Serializes the GenieStartConversationMessageRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.content is not None:
-            body["content"] = self.content
-        if self.space_id is not None:
-            body["space_id"] = self.space_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the GenieStartConversationMessageRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.content is not None:
-            body["content"] = self.content
-        if self.space_id is not None:
-            body["space_id"] = self.space_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> GenieStartConversationMessageRequest:
-        """Deserializes the GenieStartConversationMessageRequest from a dictionary."""
-        return cls(content=d.get("content", None), space_id=d.get("space_id", None))
-
-
 @dataclass
 class GenieStartConversationResponse:
     message_id: str
@@ -1159,102 +1084,6 @@ class MessageStatus(Enum):
     SUBMITTED = "SUBMITTED"
 
 
-@dataclass
-class MigrateDashboardRequest:
-    source_dashboard_id: str
-    """UUID of the dashboard to be migrated."""
-
-    display_name: Optional[str] = None
-    """Display name for the new Lakeview dashboard."""
-
-    parent_path: Optional[str] = None
-    """The workspace path of the folder to contain the migrated Lakeview dashboard."""
-
-    update_parameter_syntax: Optional[bool] = None
-    """Flag to indicate if mustache parameter syntax ({{ param }}) should be auto-updated to named
-    syntax (:param) when converting datasets in the dashboard."""
-
-    def as_dict(self) -> dict:
-        """Serializes the MigrateDashboardRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.display_name is not None:
-            body["display_name"] = self.display_name
-        if self.parent_path is not None:
-            body["parent_path"] = self.parent_path
-        if self.source_dashboard_id is not None:
-            body["source_dashboard_id"] = self.source_dashboard_id
-        if self.update_parameter_syntax is not None:
-            body["update_parameter_syntax"] = self.update_parameter_syntax
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the MigrateDashboardRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.display_name is not None:
-            body["display_name"] = self.display_name
-        if self.parent_path is not None:
-            body["parent_path"] = self.parent_path
-        if self.source_dashboard_id is not None:
-            body["source_dashboard_id"] = self.source_dashboard_id
-        if self.update_parameter_syntax is not None:
-            body["update_parameter_syntax"] = self.update_parameter_syntax
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> MigrateDashboardRequest:
-        """Deserializes the MigrateDashboardRequest from a dictionary."""
-        return cls(
-            display_name=d.get("display_name", None),
-            parent_path=d.get("parent_path", None),
-            source_dashboard_id=d.get("source_dashboard_id", None),
-            update_parameter_syntax=d.get("update_parameter_syntax", None),
-        )
-
-
-@dataclass
-class PublishRequest:
-    dashboard_id: Optional[str] = None
-    """UUID identifying the dashboard to be published."""
-
-    embed_credentials: Optional[bool] = None
-    """Flag to indicate if the publisher's credentials should be embedded in the published dashboard.
-    These embedded credentials will be used to execute the published dashboard's queries."""
-
-    warehouse_id: Optional[str] = None
-    """The ID of the warehouse that can be used to override the warehouse which was set in the draft."""
-
-    def as_dict(self) -> dict:
-        """Serializes the PublishRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.dashboard_id is not None:
-            body["dashboard_id"] = self.dashboard_id
-        if self.embed_credentials is not None:
-            body["embed_credentials"] = self.embed_credentials
-        if self.warehouse_id is not None:
-            body["warehouse_id"] = self.warehouse_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the PublishRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.dashboard_id is not None:
-            body["dashboard_id"] = self.dashboard_id
-        if self.embed_credentials is not None:
-            body["embed_credentials"] = self.embed_credentials
-        if self.warehouse_id is not None:
-            body["warehouse_id"] = self.warehouse_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> PublishRequest:
-        """Deserializes the PublishRequest from a dictionary."""
-        return cls(
-            dashboard_id=d.get("dashboard_id", None),
-            embed_credentials=d.get("embed_credentials", None),
-            warehouse_id=d.get("warehouse_id", None),
-        )
-
-
 @dataclass
 class PublishedDashboard:
     display_name: Optional[str] = None
@@ -2549,12 +2378,7 @@ class LakeviewEmbeddedAPI:
     def get_published_dashboard_token_info(
         self, dashboard_id: str, *, external_value: Optional[str] = None, external_viewer_id: Optional[str] = None
     ) -> GetPublishedDashboardTokenInfoResponse:
-        """Get a required authorization details and scopes of a published dashboard to mint an OAuth token. The
-        `authorization_details` can be enriched to apply additional restriction.
-
-        Example: Adding the following `authorization_details` object to downscope the viewer permission to
-        specific table ``` { type: "unity_catalog_privileges", privileges: ["SELECT"], object_type: "TABLE",
-        object_full_path: "main.default.testdata" } ```
+        """Get a required authorization details and scopes of a published dashboard to mint an OAuth token.
 
         :param dashboard_id: str
           UUID identifying the published dashboard.

databricks/sdk/service/database.py

@@ -586,51 +586,6 @@ class DeltaTableSyncInfo:
         )
 
 
-@dataclass
-class GenerateDatabaseCredentialRequest:
-    """Generates a credential that can be used to access database instances"""
-
-    claims: Optional[List[RequestedClaims]] = None
-    """The returned token will be scoped to the union of instance_names and instances containing the
-    specified UC tables, so instance_names is allowed to be empty."""
-
-    instance_names: Optional[List[str]] = None
-    """Instances to which the token will be scoped."""
-
-    request_id: Optional[str] = None
-
-    def as_dict(self) -> dict:
-        """Serializes the GenerateDatabaseCredentialRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.claims:
-            body["claims"] = [v.as_dict() for v in self.claims]
-        if self.instance_names:
-            body["instance_names"] = [v for v in self.instance_names]
-        if self.request_id is not None:
-            body["request_id"] = self.request_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the GenerateDatabaseCredentialRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.claims:
-            body["claims"] = self.claims
-        if self.instance_names:
-            body["instance_names"] = self.instance_names
-        if self.request_id is not None:
-            body["request_id"] = self.request_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> GenerateDatabaseCredentialRequest:
-        """Deserializes the GenerateDatabaseCredentialRequest from a dictionary."""
-        return cls(
-            claims=_repeated_dict(d, "claims", RequestedClaims),
-            instance_names=d.get("instance_names", None),
-            request_id=d.get("request_id", None),
-        )
-
-
 @dataclass
 class ListDatabaseInstanceRolesResponse:
     database_instance_roles: Optional[List[DatabaseInstanceRole]] = None
@@ -707,11 +662,15 @@ class NewPipelineSpec:
     fields of pipeline are still inferred by table def internally"""
 
     storage_catalog: Optional[str] = None
-    """UC catalog for the pipeline to store intermediate files (checkpoints, event logs etc). This
+    """This field needs to be specified if the destination catalog is a managed postgres catalog.
+    
+    UC catalog for the pipeline to store intermediate files (checkpoints, event logs etc). This
     needs to be a standard catalog where the user has permissions to create Delta tables."""
 
     storage_schema: Optional[str] = None
-    """UC schema for the pipeline to store intermediate files (checkpoints, event logs etc). This needs
+    """This field needs to be specified if the destination catalog is a managed postgres catalog.
+    
+    UC schema for the pipeline to store intermediate files (checkpoints, event logs etc). This needs
     to be in the standard catalog where the user has permissions to create Delta tables."""
 
     def as_dict(self) -> dict:
@@ -748,6 +707,13 @@ class ProvisioningInfoState(Enum):
     UPDATING = "UPDATING"
 
 
+class ProvisioningPhase(Enum):
+
+    PROVISIONING_PHASE_INDEX_SCAN = "PROVISIONING_PHASE_INDEX_SCAN"
+    PROVISIONING_PHASE_INDEX_SORT = "PROVISIONING_PHASE_INDEX_SORT"
+    PROVISIONING_PHASE_MAIN = "PROVISIONING_PHASE_MAIN"
+
+
 @dataclass
 class RequestedClaims:
     permission_set: Optional[RequestedClaimsPermissionSet] = None
@@ -1001,6 +967,9 @@ class SyncedTablePipelineProgress:
     """The source table Delta version that was last processed by the pipeline. The pipeline may not
     have completely processed this version yet."""
 
+    provisioning_phase: Optional[ProvisioningPhase] = None
+    """The current phase of the data synchronization pipeline."""
+
     sync_progress_completion: Optional[float] = None
     """The completion ratio of this update. This is a number between 0 and 1."""
 
@@ -1017,6 +986,8 @@ class SyncedTablePipelineProgress:
             body["estimated_completion_time_seconds"] = self.estimated_completion_time_seconds
         if self.latest_version_currently_processing is not None:
             body["latest_version_currently_processing"] = self.latest_version_currently_processing
+        if self.provisioning_phase is not None:
+            body["provisioning_phase"] = self.provisioning_phase.value
         if self.sync_progress_completion is not None:
             body["sync_progress_completion"] = self.sync_progress_completion
         if self.synced_row_count is not None:
@@ -1032,6 +1003,8 @@ class SyncedTablePipelineProgress:
             body["estimated_completion_time_seconds"] = self.estimated_completion_time_seconds
         if self.latest_version_currently_processing is not None:
             body["latest_version_currently_processing"] = self.latest_version_currently_processing
+        if self.provisioning_phase is not None:
+            body["provisioning_phase"] = self.provisioning_phase
         if self.sync_progress_completion is not None:
             body["sync_progress_completion"] = self.sync_progress_completion
         if self.synced_row_count is not None:
@@ -1046,6 +1019,7 @@ class SyncedTablePipelineProgress:
         return cls(
             estimated_completion_time_seconds=d.get("estimated_completion_time_seconds", None),
             latest_version_currently_processing=d.get("latest_version_currently_processing", None),
+            provisioning_phase=_enum(d, "provisioning_phase", ProvisioningPhase),
             sync_progress_completion=d.get("sync_progress_completion", None),
             synced_row_count=d.get("synced_row_count", None),
             total_row_count=d.get("total_row_count", None),
@@ -1144,13 +1118,20 @@ class SyncedTableSpec:
     do not already exist."""
 
     existing_pipeline_id: Optional[str] = None
-    """User-specified ID of a pre-existing pipeline to bin pack. This field is optional, and should be
-    empty if new_pipeline_spec is set. This field will only be set by the server in response
-    messages if it is specified in the request. The SyncedTableStatus message will always contain
-    the effective pipeline ID (either client provided or server generated), however."""
+    """At most one of existing_pipeline_id and new_pipeline_spec should be defined.
+    
+    If existing_pipeline_id is defined, the synced table will be bin packed into the existing
+    pipeline referenced. This avoids creating a new pipeline and allows sharing existing compute. In
+    this case, the scheduling_policy of this synced table must match the scheduling policy of the
+    existing pipeline."""
 
     new_pipeline_spec: Optional[NewPipelineSpec] = None
-    """Spec of new pipeline. Should be empty if pipeline_id / existing_pipeline_id is set"""
+    """At most one of existing_pipeline_id and new_pipeline_spec should be defined.
+    
+    If new_pipeline_spec is defined, a new pipeline is created for this synced table. The location
+    pointed to is used to store intermediate files (checkpoints, event logs etc). The caller must
+    have write permissions to create Delta tables in the specified catalog and schema. Again, note
+    this requires write permissions, whereas the source table only requires read permissions."""
 
     primary_key_columns: Optional[List[str]] = None
     """Primary Key columns to be used for data insert/update in the destination."""
@@ -1769,7 +1750,7 @@ class DatabaseAPI:
           The name of the instance. This is the unique identifier for the instance.
         :param database_instance: :class:`DatabaseInstance`
         :param update_mask: str
-          The list of fields to update.
+          The list of fields to update. This field is not yet supported, and is ignored by the server.
 
         :returns: :class:`DatabaseInstance`
         """

databricks/sdk/service/files.py

@@ -14,38 +14,6 @@ _LOG = logging.getLogger("databricks.sdk")
 # all definitions in this file are in alphabetical order
 
 
-@dataclass
-class AddBlock:
-    handle: int
-    """The handle on an open stream."""
-
-    data: str
-    """The base64-encoded data to append to the stream. This has a limit of 1 MB."""
-
-    def as_dict(self) -> dict:
-        """Serializes the AddBlock into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.data is not None:
-            body["data"] = self.data
-        if self.handle is not None:
-            body["handle"] = self.handle
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the AddBlock into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.data is not None:
-            body["data"] = self.data
-        if self.handle is not None:
-            body["handle"] = self.handle
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> AddBlock:
-        """Deserializes the AddBlock from a dictionary."""
-        return cls(data=d.get("data", None), handle=d.get("handle", None))
-
-
 @dataclass
 class AddBlockResponse:
     def as_dict(self) -> dict:
@@ -64,31 +32,6 @@ class AddBlockResponse:
         return cls()
 
 
-@dataclass
-class Close:
-    handle: int
-    """The handle on an open stream."""
-
-    def as_dict(self) -> dict:
-        """Serializes the Close into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.handle is not None:
-            body["handle"] = self.handle
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the Close into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.handle is not None:
-            body["handle"] = self.handle
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> Close:
-        """Deserializes the Close from a dictionary."""
-        return cls(handle=d.get("handle", None))
-
-
 @dataclass
 class CloseResponse:
     def as_dict(self) -> dict:
@@ -107,38 +50,6 @@ class CloseResponse:
         return cls()
 
 
-@dataclass
-class Create:
-    path: str
-    """The path of the new file. The path should be the absolute DBFS path."""
-
-    overwrite: Optional[bool] = None
-    """The flag that specifies whether to overwrite existing file/files."""
-
-    def as_dict(self) -> dict:
-        """Serializes the Create into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.overwrite is not None:
-            body["overwrite"] = self.overwrite
-        if self.path is not None:
-            body["path"] = self.path
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the Create into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.overwrite is not None:
-            body["overwrite"] = self.overwrite
-        if self.path is not None:
-            body["path"] = self.path
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> Create:
-        """Deserializes the Create from a dictionary."""
-        return cls(overwrite=d.get("overwrite", None), path=d.get("path", None))
-
-
 @dataclass
 class CreateDirectoryResponse:
     def as_dict(self) -> dict:
@@ -183,39 +94,6 @@ class CreateResponse:
         return cls(handle=d.get("handle", None))
 
 
-@dataclass
-class Delete:
-    path: str
-    """The path of the file or directory to delete. The path should be the absolute DBFS path."""
-
-    recursive: Optional[bool] = None
-    """Whether or not to recursively delete the directory's contents. Deleting empty directories can be
-    done without providing the recursive flag."""
-
-    def as_dict(self) -> dict:
-        """Serializes the Delete into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.path is not None:
-            body["path"] = self.path
-        if self.recursive is not None:
-            body["recursive"] = self.recursive
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the Delete into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.path is not None:
-            body["path"] = self.path
-        if self.recursive is not None:
-            body["recursive"] = self.recursive
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> Delete:
-        """Deserializes the Delete from a dictionary."""
-        return cls(path=d.get("path", None), recursive=d.get("recursive", None))
-
-
 @dataclass
 class DeleteDirectoryResponse:
     def as_dict(self) -> dict:
@@ -530,31 +408,6 @@ class ListStatusResponse:
         return cls(files=_repeated_dict(d, "files", FileInfo))
 
 
-@dataclass
-class MkDirs:
-    path: str
-    """The path of the new directory. The path should be the absolute DBFS path."""
-
-    def as_dict(self) -> dict:
-        """Serializes the MkDirs into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.path is not None:
-            body["path"] = self.path
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the MkDirs into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.path is not None:
-            body["path"] = self.path
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> MkDirs:
-        """Deserializes the MkDirs from a dictionary."""
-        return cls(path=d.get("path", None))
-
-
 @dataclass
 class MkDirsResponse:
     def as_dict(self) -> dict:
@@ -573,38 +426,6 @@ class MkDirsResponse:
         return cls()
 
 
-@dataclass
-class Move:
-    source_path: str
-    """The source path of the file or directory. The path should be the absolute DBFS path."""
-
-    destination_path: str
-    """The destination path of the file or directory. The path should be the absolute DBFS path."""
-
-    def as_dict(self) -> dict:
-        """Serializes the Move into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.destination_path is not None:
-            body["destination_path"] = self.destination_path
-        if self.source_path is not None:
-            body["source_path"] = self.source_path
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the Move into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.destination_path is not None:
-            body["destination_path"] = self.destination_path
-        if self.source_path is not None:
-            body["source_path"] = self.source_path
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> Move:
-        """Deserializes the Move from a dictionary."""
-        return cls(destination_path=d.get("destination_path", None), source_path=d.get("source_path", None))
-
-
 @dataclass
 class MoveResponse:
     def as_dict(self) -> dict:
@@ -623,45 +444,6 @@ class MoveResponse:
         return cls()
 
 
-@dataclass
-class Put:
-    path: str
-    """The path of the new file. The path should be the absolute DBFS path."""
-
-    contents: Optional[str] = None
-    """This parameter might be absent, and instead a posted file will be used."""
-
-    overwrite: Optional[bool] = None
-    """The flag that specifies whether to overwrite existing file/files."""
-
-    def as_dict(self) -> dict:
-        """Serializes the Put into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.contents is not None:
-            body["contents"] = self.contents
-        if self.overwrite is not None:
-            body["overwrite"] = self.overwrite
-        if self.path is not None:
-            body["path"] = self.path
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the Put into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.contents is not None:
-            body["contents"] = self.contents
-        if self.overwrite is not None:
-            body["overwrite"] = self.overwrite
-        if self.path is not None:
-            body["path"] = self.path
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> Put:
-        """Deserializes the Put from a dictionary."""
-        return cls(contents=d.get("contents", None), overwrite=d.get("overwrite", None), path=d.get("path", None))
-
-
 @dataclass
 class PutResponse:
     def as_dict(self) -> dict:
@@ -1097,6 +879,7 @@ class FilesAPI:
         headers = {
             "Accept": "application/octet-stream",
         }
+
         response_headers = [
             "content-length",
             "content-type",
@@ -1142,6 +925,7 @@ class FilesAPI:
         """
 
         headers = {}
+
         response_headers = [
             "content-length",
             "content-type",