databricks-sdk 0.62.0__py3-none-any.whl → 0.63.0__py3-none-any.whl

databricks/sdk/service/cleanrooms.py

@@ -142,7 +142,8 @@ class CleanRoomAsset:
     For UC securable assets (tables, volumes, etc.), the format is
     *shared_catalog*.*shared_schema*.*asset_name*
     
-    For notebooks, the name is the notebook file name."""
+    For notebooks, the name is the notebook file name. For jar analyses, the name is the jar
+    analysis name."""
 
     asset_type: CleanRoomAssetAssetType
     """The type of the asset."""
@@ -351,7 +352,7 @@ class CleanRoomAssetNotebook:
     """Server generated etag that represents the notebook version."""
 
     review_state: Optional[CleanRoomNotebookReviewNotebookReviewState] = None
-    """top-level status derived from all reviews"""
+    """Top-level status derived from all reviews"""
 
     reviews: Optional[List[CleanRoomNotebookReview]] = None
     """All existing approvals or rejections"""
@@ -546,8 +547,12 @@ class CleanRoomAssetVolumeLocalDetails:
 @dataclass
 class CleanRoomAutoApprovalRule:
     author_collaborator_alias: Optional[str] = None
+    """Collaborator alias of the author covered by the rule. Only one of `author_collaborator_alias`
+    and `author_scope` can be set."""
 
     author_scope: Optional[CleanRoomAutoApprovalRuleAuthorScope] = None
+    """Scope of authors covered by the rule. Only one of `author_collaborator_alias` and `author_scope`
+    can be set."""
 
     clean_room_name: Optional[str] = None
     """The name of the clean room this auto-approval rule belongs to."""
@@ -562,6 +567,7 @@ class CleanRoomAutoApprovalRule:
     """The owner of the rule to whom the rule applies."""
 
     runner_collaborator_alias: Optional[str] = None
+    """Collaborator alias of the runner covered by the rule."""
 
     def as_dict(self) -> dict:
         """Serializes the CleanRoomAutoApprovalRule into a dictionary suitable for use as a JSON request body."""
@@ -704,19 +710,19 @@ class CleanRoomCollaborator:
 @dataclass
 class CleanRoomNotebookReview:
     comment: Optional[str] = None
-    """review comment"""
+    """Review comment"""
 
     created_at_millis: Optional[int] = None
-    """timestamp of when the review was submitted"""
+    """When the review was submitted, in epoch milliseconds"""
 
     review_state: Optional[CleanRoomNotebookReviewNotebookReviewState] = None
-    """review outcome"""
+    """Review outcome"""
 
     review_sub_reason: Optional[CleanRoomNotebookReviewNotebookReviewSubReason] = None
-    """specified when the review was not explicitly made by a user"""
+    """Specified when the review was not explicitly made by a user"""
 
     reviewer_collaborator_alias: Optional[str] = None
-    """collaborator alias of the reviewer"""
+    """Collaborator alias of the reviewer"""
 
     def as_dict(self) -> dict:
         """Serializes the CleanRoomNotebookReview into a dictionary suitable for use as a JSON request body."""
@@ -1100,7 +1106,7 @@ class ComplianceSecurityProfile:
 @dataclass
 class CreateCleanRoomAssetReviewResponse:
     notebook_review_state: Optional[CleanRoomNotebookReviewNotebookReviewState] = None
-    """top-level status derived from all reviews"""
+    """Top-level status derived from all reviews"""
 
     notebook_reviews: Optional[List[CleanRoomNotebookReview]] = None
     """All existing notebook approvals or rejections"""
@@ -1348,13 +1354,13 @@ class ListCleanRoomsResponse:
 @dataclass
 class NotebookVersionReview:
     etag: str
-    """etag that identifies the notebook version"""
+    """Etag identifying the notebook version"""
 
     review_state: CleanRoomNotebookReviewNotebookReviewState
-    """review outcome"""
+    """Review outcome"""
 
     comment: Optional[str] = None
-    """review comment"""
+    """Review comment"""
 
     def as_dict(self) -> dict:
         """Serializes the NotebookVersionReview into a dictionary suitable for use as a JSON request body."""
@@ -1505,12 +1511,12 @@ class CleanRoomAssetsAPI:
         name: str,
         notebook_review: NotebookVersionReview,
     ) -> CreateCleanRoomAssetReviewResponse:
-        """submit an asset review
+        """Submit an asset review
 
         :param clean_room_name: str
           Name of the clean room
         :param asset_type: :class:`CleanRoomAssetAssetType`
-          can only be NOTEBOOK_FILE for now
+          Asset type. Can only be NOTEBOOK_FILE.
         :param name: str
           Name of the asset
         :param notebook_review: :class:`NotebookVersionReview`
@@ -1620,7 +1626,8 @@ class CleanRoomAssetsAPI:
           For UC securable assets (tables, volumes, etc.), the format is
           *shared_catalog*.*shared_schema*.*asset_name*
 
-          For notebooks, the name is the notebook file name.
+          For notebooks, the name is the notebook file name. For jar analyses, the name is the jar analysis
+          name.
         :param asset: :class:`CleanRoomAsset`
           The asset to update. The asset's `name` and `asset_type` fields are used to identify the asset to
           update.

databricks/sdk/service/compute.py

@@ -3410,6 +3410,15 @@ class GcpAttributes:
     boot_disk_size: Optional[int] = None
     """Boot disk size in GB"""
 
+    first_on_demand: Optional[int] = None
+    """The first `first_on_demand` nodes of the cluster will be placed on on-demand instances. This
+    value should be greater than 0, to make sure the cluster driver node is placed on an on-demand
+    instance. If this value is greater than or equal to the current cluster size, all nodes will be
+    placed on on-demand instances. If this value is less than the current cluster size,
+    `first_on_demand` nodes will be placed on on-demand instances and the remainder will be placed
+    on `availability` instances. Note that this value does not affect cluster size and cannot
+    currently be mutated over the lifetime of a cluster."""
+
     google_service_account: Optional[str] = None
     """If provided, the cluster will impersonate the google service account when accessing gcloud
     services (like GCS). The google service account must have previously been added to the
@@ -3441,6 +3450,8 @@ class GcpAttributes:
             body["availability"] = self.availability.value
         if self.boot_disk_size is not None:
             body["boot_disk_size"] = self.boot_disk_size
+        if self.first_on_demand is not None:
+            body["first_on_demand"] = self.first_on_demand
         if self.google_service_account is not None:
             body["google_service_account"] = self.google_service_account
         if self.local_ssd_count is not None:
@@ -3458,6 +3469,8 @@ class GcpAttributes:
             body["availability"] = self.availability
         if self.boot_disk_size is not None:
             body["boot_disk_size"] = self.boot_disk_size
+        if self.first_on_demand is not None:
+            body["first_on_demand"] = self.first_on_demand
         if self.google_service_account is not None:
             body["google_service_account"] = self.google_service_account
         if self.local_ssd_count is not None:
@@ -3474,6 +3487,7 @@ class GcpAttributes:
         return cls(
             availability=_enum(d, "availability", GcpAvailability),
             boot_disk_size=d.get("boot_disk_size", None),
+            first_on_demand=d.get("first_on_demand", None),
             google_service_account=d.get("google_service_account", None),
             local_ssd_count=d.get("local_ssd_count", None),
             use_preemptible_executors=d.get("use_preemptible_executors", None),

databricks/sdk/service/database.py

@@ -589,6 +589,40 @@ class DeltaTableSyncInfo:
         )
 
 
+@dataclass
+class ListDatabaseCatalogsResponse:
+    database_catalogs: Optional[List[DatabaseCatalog]] = None
+
+    next_page_token: Optional[str] = None
+    """Pagination token to request the next page of database catalogs."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ListDatabaseCatalogsResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.database_catalogs:
+            body["database_catalogs"] = [v.as_dict() for v in self.database_catalogs]
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListDatabaseCatalogsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.database_catalogs:
+            body["database_catalogs"] = self.database_catalogs
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ListDatabaseCatalogsResponse:
+        """Deserializes the ListDatabaseCatalogsResponse from a dictionary."""
+        return cls(
+            database_catalogs=_repeated_dict(d, "database_catalogs", DatabaseCatalog),
+            next_page_token=d.get("next_page_token", None),
+        )
+
+
 @dataclass
 class ListDatabaseInstanceRolesResponse:
     database_instance_roles: Optional[List[DatabaseInstanceRole]] = None
@@ -659,6 +693,40 @@ class ListDatabaseInstancesResponse:
         )
 
 
+@dataclass
+class ListSyncedDatabaseTablesResponse:
+    next_page_token: Optional[str] = None
+    """Pagination token to request the next page of synced tables."""
+
+    synced_tables: Optional[List[SyncedDatabaseTable]] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the ListSyncedDatabaseTablesResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        if self.synced_tables:
+            body["synced_tables"] = [v.as_dict() for v in self.synced_tables]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListSyncedDatabaseTablesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        if self.synced_tables:
+            body["synced_tables"] = self.synced_tables
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ListSyncedDatabaseTablesResponse:
+        """Deserializes the ListSyncedDatabaseTablesResponse from a dictionary."""
+        return cls(
+            next_page_token=d.get("next_page_token", None),
+            synced_tables=_repeated_dict(d, "synced_tables", SyncedDatabaseTable),
+        )
+
+
 @dataclass
 class NewPipelineSpec:
     """Custom fields that user can set for pipeline while creating SyncedDatabaseTable. Note that other
@@ -1733,10 +1801,47 @@ class DatabaseAPI:
         res = self._api.do("GET", f"/api/2.0/database/synced_tables/{name}", headers=headers)
         return SyncedDatabaseTable.from_dict(res)
 
+    def list_database_catalogs(
+        self, instance_name: str, *, page_size: Optional[int] = None, page_token: Optional[str] = None
+    ) -> Iterator[DatabaseCatalog]:
+        """This API is currently unimplemented, but exposed for Terraform support.
+
+        :param instance_name: str
+          Name of the instance to get database catalogs for.
+        :param page_size: int (optional)
+          Upper bound for items returned.
+        :param page_token: str (optional)
+          Pagination token to go to the next page of synced database tables. Requests first page if absent.
+
+        :returns: Iterator over :class:`DatabaseCatalog`
+        """
+
+        query = {}
+        if page_size is not None:
+            query["page_size"] = page_size
+        if page_token is not None:
+            query["page_token"] = page_token
+        headers = {
+            "Accept": "application/json",
+        }
+
+        while True:
+            json = self._api.do(
+                "GET", f"/api/2.0/database/instances/{instance_name}/catalogs", query=query, headers=headers
+            )
+            if "database_catalogs" in json:
+                for v in json["database_catalogs"]:
+                    yield DatabaseCatalog.from_dict(v)
+            if "next_page_token" not in json or not json["next_page_token"]:
+                return
+            query["page_token"] = json["next_page_token"]
+
     def list_database_instance_roles(
         self, instance_name: str, *, page_size: Optional[int] = None, page_token: Optional[str] = None
     ) -> Iterator[DatabaseInstanceRole]:
-        """START OF PG ROLE APIs Section
+        """START OF PG ROLE APIs Section These APIs are marked a PUBLIC with stage < PUBLIC_PREVIEW. With more
+        recent Lakebase V2 plans, we don't plan to ever advance these to PUBLIC_PREVIEW. These APIs will
+        remain effectively undocumented/UI-only and we'll aim for a new public roles API as part of V2 PuPr.
 
         :param instance_name: str
         :param page_size: int (optional)
@@ -1798,6 +1903,67 @@ class DatabaseAPI:
                 return
             query["page_token"] = json["next_page_token"]
 
+    def list_synced_database_tables(
+        self, instance_name: str, *, page_size: Optional[int] = None, page_token: Optional[str] = None
+    ) -> Iterator[SyncedDatabaseTable]:
+        """This API is currently unimplemented, but exposed for Terraform support.
+
+        :param instance_name: str
+          Name of the instance to get synced tables for.
+        :param page_size: int (optional)
+          Upper bound for items returned.
+        :param page_token: str (optional)
+          Pagination token to go to the next page of synced database tables. Requests first page if absent.
+
+        :returns: Iterator over :class:`SyncedDatabaseTable`
+        """
+
+        query = {}
+        if page_size is not None:
+            query["page_size"] = page_size
+        if page_token is not None:
+            query["page_token"] = page_token
+        headers = {
+            "Accept": "application/json",
+        }
+
+        while True:
+            json = self._api.do(
+                "GET", f"/api/2.0/database/instances/{instance_name}/synced_tables", query=query, headers=headers
+            )
+            if "synced_tables" in json:
+                for v in json["synced_tables"]:
+                    yield SyncedDatabaseTable.from_dict(v)
+            if "next_page_token" not in json or not json["next_page_token"]:
+                return
+            query["page_token"] = json["next_page_token"]
+
+    def update_database_catalog(
+        self, name: str, database_catalog: DatabaseCatalog, update_mask: str
+    ) -> DatabaseCatalog:
+        """This API is currently unimplemented, but exposed for Terraform support.
+
+        :param name: str
+          The name of the catalog in UC.
+        :param database_catalog: :class:`DatabaseCatalog`
+          Note that updating a database catalog is not yet supported.
+        :param update_mask: str
+          The list of fields to update. Setting this field is not yet supported.
+
+        :returns: :class:`DatabaseCatalog`
+        """
+        body = database_catalog.as_dict()
+        query = {}
+        if update_mask is not None:
+            query["update_mask"] = update_mask
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do("PATCH", f"/api/2.0/database/catalogs/{name}", query=query, body=body, headers=headers)
+        return DatabaseCatalog.from_dict(res)
+
     def update_database_instance(
         self, name: str, database_instance: DatabaseInstance, update_mask: str
     ) -> DatabaseInstance:
@@ -1807,7 +1973,8 @@ 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. This field is not yet supported, and is ignored by the server.
+          The list of fields to update. If unspecified, all fields will be updated when possible. To wipe out
+          custom_tags, specify custom_tags in the update_mask with an empty custom_tags map.
 
         :returns: :class:`DatabaseInstance`
         """
@@ -1822,3 +1989,29 @@ class DatabaseAPI:
 
         res = self._api.do("PATCH", f"/api/2.0/database/instances/{name}", query=query, body=body, headers=headers)
         return DatabaseInstance.from_dict(res)
+
+    def update_synced_database_table(
+        self, name: str, synced_table: SyncedDatabaseTable, update_mask: str
+    ) -> SyncedDatabaseTable:
+        """This API is currently unimplemented, but exposed for Terraform support.
+
+        :param name: str
+          Full three-part (catalog, schema, table) name of the table.
+        :param synced_table: :class:`SyncedDatabaseTable`
+          Note that updating a synced database table is not yet supported.
+        :param update_mask: str
+          The list of fields to update. Setting this field is not yet supported.
+
+        :returns: :class:`SyncedDatabaseTable`
+        """
+        body = synced_table.as_dict()
+        query = {}
+        if update_mask is not None:
+            query["update_mask"] = update_mask
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do("PATCH", f"/api/2.0/database/synced_tables/{name}", query=query, body=body, headers=headers)
+        return SyncedDatabaseTable.from_dict(res)

databricks/sdk/service/jobs.py

@@ -3037,6 +3037,11 @@ class JobSettings:
     the job runs only when triggered by clicking “Run Now” in the Jobs UI or sending an API
     request to `runNow`."""
 
+    usage_policy_id: Optional[str] = None
+    """The id of the user specified usage policy to use for this job. If not specified, a default usage
+    policy may be applied when creating or modifying the job. See `effective_budget_policy_id` for
+    the budget policy used by this workload."""
+
     webhook_notifications: Optional[WebhookNotifications] = None
     """A collection of system notification IDs to notify when runs of this job begin or complete."""
 
@@ -3089,6 +3094,8 @@ class JobSettings:
             body["timeout_seconds"] = self.timeout_seconds
         if self.trigger:
             body["trigger"] = self.trigger.as_dict()
+        if self.usage_policy_id is not None:
+            body["usage_policy_id"] = self.usage_policy_id
         if self.webhook_notifications:
             body["webhook_notifications"] = self.webhook_notifications.as_dict()
         return body
@@ -3142,6 +3149,8 @@ class JobSettings:
             body["timeout_seconds"] = self.timeout_seconds
         if self.trigger:
             body["trigger"] = self.trigger
+        if self.usage_policy_id is not None:
+            body["usage_policy_id"] = self.usage_policy_id
         if self.webhook_notifications:
             body["webhook_notifications"] = self.webhook_notifications
         return body
@@ -3173,6 +3182,7 @@ class JobSettings:
             tasks=_repeated_dict(d, "tasks", Task),
             timeout_seconds=d.get("timeout_seconds", None),
             trigger=_from_dict(d, "trigger", TriggerSettings),
+            usage_policy_id=d.get("usage_policy_id", None),
             webhook_notifications=_from_dict(d, "webhook_notifications", WebhookNotifications),
         )
 
@@ -7884,6 +7894,8 @@ class TerminationCodeCode(Enum):
     run failed due to a cloud provider issue. Refer to the state message for further details. *
     `MAX_JOB_QUEUE_SIZE_EXCEEDED`: The run was skipped due to reaching the job level queue size
     limit. * `DISABLED`: The run was never executed because it was disabled explicitly by the user.
+    * `BREAKING_CHANGE`: Run failed because of an intentional breaking change in Spark, but it will
+    be retried with a mitigation config.
 
     [Link]: https://kb.databricks.com/en_US/notebooks/too-many-execution-contexts-are-open-right-now"""
 
@@ -8437,6 +8449,7 @@ class JobsAPI:
         tasks: Optional[List[Task]] = None,
         timeout_seconds: Optional[int] = None,
         trigger: Optional[TriggerSettings] = None,
+        usage_policy_id: Optional[str] = None,
         webhook_notifications: Optional[WebhookNotifications] = None,
     ) -> CreateResponse:
         """Create a new job.
@@ -8531,6 +8544,10 @@ class JobsAPI:
           A configuration to trigger a run when certain conditions are met. The default behavior is that the
           job runs only when triggered by clicking “Run Now” in the Jobs UI or sending an API request to
           `runNow`.
+        :param usage_policy_id: str (optional)
+          The id of the user specified usage policy to use for this job. If not specified, a default usage
+          policy may be applied when creating or modifying the job. See `effective_budget_policy_id` for the
+          budget policy used by this workload.
         :param webhook_notifications: :class:`WebhookNotifications` (optional)
           A collection of system notification IDs to notify when runs of this job begin or complete.
 
@@ -8585,6 +8602,8 @@ class JobsAPI:
             body["timeout_seconds"] = timeout_seconds
         if trigger is not None:
             body["trigger"] = trigger.as_dict()
+        if usage_policy_id is not None:
+            body["usage_policy_id"] = usage_policy_id
         if webhook_notifications is not None:
             body["webhook_notifications"] = webhook_notifications.as_dict()
         headers = {
@@ -9381,6 +9400,7 @@ class JobsAPI:
         run_name: Optional[str] = None,
         tasks: Optional[List[SubmitTask]] = None,
         timeout_seconds: Optional[int] = None,
+        usage_policy_id: Optional[str] = None,
         webhook_notifications: Optional[WebhookNotifications] = None,
     ) -> Wait[Run]:
         """Submit a one-time run. This endpoint allows you to submit a workload directly without creating a job.
@@ -9432,6 +9452,9 @@ class JobsAPI:
         :param tasks: List[:class:`SubmitTask`] (optional)
         :param timeout_seconds: int (optional)
           An optional timeout applied to each run of this job. A value of `0` means no timeout.
+        :param usage_policy_id: str (optional)
+          The user specified id of the usage policy to use for this one-time run. If not specified, a default
+          usage policy may be applied when creating or modifying the job.
         :param webhook_notifications: :class:`WebhookNotifications` (optional)
           A collection of system notification IDs to notify when the run begins or completes.
 
@@ -9466,6 +9489,8 @@ class JobsAPI:
             body["tasks"] = [v.as_dict() for v in tasks]
         if timeout_seconds is not None:
             body["timeout_seconds"] = timeout_seconds
+        if usage_policy_id is not None:
+            body["usage_policy_id"] = usage_policy_id
         if webhook_notifications is not None:
             body["webhook_notifications"] = webhook_notifications.as_dict()
         headers = {
@@ -9496,6 +9521,7 @@ class JobsAPI:
         run_name: Optional[str] = None,
         tasks: Optional[List[SubmitTask]] = None,
         timeout_seconds: Optional[int] = None,
+        usage_policy_id: Optional[str] = None,
         webhook_notifications: Optional[WebhookNotifications] = None,
         timeout=timedelta(minutes=20),
     ) -> Run:
@@ -9513,6 +9539,7 @@ class JobsAPI:
             run_name=run_name,
             tasks=tasks,
             timeout_seconds=timeout_seconds,
+            usage_policy_id=usage_policy_id,
             webhook_notifications=webhook_notifications,
         ).result(timeout=timeout)
 

databricks/sdk/service/ml.py

@@ -3494,10 +3494,8 @@ class PublishSpec:
     online_table_name: str
     """The full three-part (catalog, schema, table) name of the online table."""
 
-    publish_mode: Optional[PublishSpecPublishMode] = None
-    """The publish mode of the pipeline that syncs the online table with the source table. Defaults to
-    TRIGGERED if not specified. All publish modes require the source table to have Change Data Feed
-    (CDF) enabled."""
+    publish_mode: PublishSpecPublishMode
+    """The publish mode of the pipeline that syncs the online table with the source table."""
 
     def as_dict(self) -> dict:
         """Serializes the PublishSpec into a dictionary suitable for use as a JSON request body."""
@@ -3534,6 +3532,7 @@ class PublishSpec:
 class PublishSpecPublishMode(Enum):
 
     CONTINUOUS = "CONTINUOUS"
+    SNAPSHOT = "SNAPSHOT"
     TRIGGERED = "TRIGGERED"
 
 

databricks/sdk/service/serving.py

@@ -4474,6 +4474,7 @@ class ServingEndpointsAPI:
         self,
         name: str,
         *,
+        client_request_id: Optional[str] = None,
         dataframe_records: Optional[List[Any]] = None,
         dataframe_split: Optional[DataframeSplitInput] = None,
         extra_params: Optional[Dict[str, str]] = None,
@@ -4487,11 +4488,15 @@ class ServingEndpointsAPI:
         stop: Optional[List[str]] = None,
         stream: Optional[bool] = None,
         temperature: Optional[float] = None,
+        usage_context: Optional[Dict[str, str]] = None,
     ) -> QueryEndpointResponse:
         """Query a serving endpoint
 
         :param name: str
           The name of the serving endpoint. This field is required and is provided via the path parameter.
+        :param client_request_id: str (optional)
+          Optional user-provided request identifier that will be recorded in the inference table and the usage
+          tracking table.
         :param dataframe_records: List[Any] (optional)
           Pandas Dataframe input in the records orientation.
         :param dataframe_split: :class:`DataframeSplitInput` (optional)
@@ -4533,10 +4538,14 @@ class ServingEndpointsAPI:
           The temperature field used ONLY for __completions__ and __chat external & foundation model__ serving
           endpoints. This is a float between 0.0 and 2.0 with a default of 1.0 and should only be used with
           other chat/completions query fields.
+        :param usage_context: Dict[str,str] (optional)
+          Optional user-provided context that will be recorded in the usage tracking table.
 
         :returns: :class:`QueryEndpointResponse`
         """
         body = {}
+        if client_request_id is not None:
+            body["client_request_id"] = client_request_id
         if dataframe_records is not None:
             body["dataframe_records"] = [v for v in dataframe_records]
         if dataframe_split is not None:
@@ -4563,6 +4572,8 @@ class ServingEndpointsAPI:
             body["stream"] = stream
         if temperature is not None:
             body["temperature"] = temperature
+        if usage_context is not None:
+            body["usage_context"] = usage_context
         headers = {
             "Accept": "application/json",
             "Content-Type": "application/json",
@@ -4777,6 +4788,7 @@ class ServingEndpointsDataPlaneAPI:
         self,
         name: str,
         *,
+        client_request_id: Optional[str] = None,
         dataframe_records: Optional[List[Any]] = None,
         dataframe_split: Optional[DataframeSplitInput] = None,
         extra_params: Optional[Dict[str, str]] = None,
@@ -4790,11 +4802,15 @@ class ServingEndpointsDataPlaneAPI:
         stop: Optional[List[str]] = None,
         stream: Optional[bool] = None,
         temperature: Optional[float] = None,
+        usage_context: Optional[Dict[str, str]] = None,
     ) -> QueryEndpointResponse:
         """Query a serving endpoint
 
         :param name: str
           The name of the serving endpoint. This field is required and is provided via the path parameter.
+        :param client_request_id: str (optional)
+          Optional user-provided request identifier that will be recorded in the inference table and the usage
+          tracking table.
         :param dataframe_records: List[Any] (optional)
           Pandas Dataframe input in the records orientation.
         :param dataframe_split: :class:`DataframeSplitInput` (optional)
@@ -4836,10 +4852,14 @@ class ServingEndpointsDataPlaneAPI:
           The temperature field used ONLY for __completions__ and __chat external & foundation model__ serving
           endpoints. This is a float between 0.0 and 2.0 with a default of 1.0 and should only be used with
           other chat/completions query fields.
+        :param usage_context: Dict[str,str] (optional)
+          Optional user-provided context that will be recorded in the usage tracking table.
 
         :returns: :class:`QueryEndpointResponse`
         """
         body = {}
+        if client_request_id is not None:
+            body["client_request_id"] = client_request_id
         if dataframe_records is not None:
             body["dataframe_records"] = [v for v in dataframe_records]
         if dataframe_split is not None:
@@ -4866,6 +4886,8 @@ class ServingEndpointsDataPlaneAPI:
             body["stream"] = stream
         if temperature is not None:
             body["temperature"] = temperature
+        if usage_context is not None:
+            body["usage_context"] = usage_context
         data_plane_info = self._data_plane_info_query(
             name=name,
         )