anyscale 0.26.69__py3-none-any.whl → 0.26.71__py3-none-any.whl

anyscale/controllers/kubernetes_verifier.py

@@ -12,6 +12,7 @@ Handles verification of Kubernetes-based cloud deployments including:
 
 from contextlib import contextmanager, suppress
 from dataclasses import dataclass
+from enum import Enum
 import json
 import os
 import shutil
@@ -90,8 +91,19 @@ KUBECTL_COMMON_PATHS = [
 # Status and result strings
 PASSED_STATUS = "PASSED"
 FAILED_STATUS = "FAILED"
+SKIPPED_STATUS = "SKIPPED"
 RUNNING_STATUS = "Running"
 
+
+# Verification status enum
+class VerificationStatus(Enum):
+    """Status of a verification check."""
+
+    PASSED = "PASSED"
+    FAILED = "FAILED"
+    SKIPPED = "SKIPPED"
+
+
 # Verification component names (for consistent reporting)
 class VerificationComponents:
     OPERATOR_POD_INSTALLED = "Operator Pod Installed"
@@ -206,15 +218,15 @@ class ResourceNotFoundError(KubernetesVerificationError):
 class VerificationResults:
     """Tracks the results of all verification steps."""
 
-    operator_pod_installed: bool = False
-    operator_health: bool = False
-    operator_identity: bool = False
-    file_storage: bool = False
-    gateway_support: bool = False
-    nginx_ingress: bool = False
+    operator_pod_installed: VerificationStatus = VerificationStatus.FAILED
+    operator_health: VerificationStatus = VerificationStatus.FAILED
+    operator_identity: VerificationStatus = VerificationStatus.FAILED
+    file_storage: VerificationStatus = VerificationStatus.FAILED
+    gateway_support: VerificationStatus = VerificationStatus.FAILED
+    nginx_ingress: VerificationStatus = VerificationStatus.FAILED
 
-    def to_dict(self) -> Dict[str, bool]:
-        """Convert to dictionary format matching original implementation."""
+    def to_dict(self) -> Dict[str, VerificationStatus]:
+        """Convert to dictionary format for reporting."""
         return {
             VerificationComponents.OPERATOR_POD_INSTALLED: self.operator_pod_installed,
             VerificationComponents.OPERATOR_HEALTH: self.operator_health,
@@ -226,9 +238,10 @@ class VerificationResults:
 
     @property
     def overall_success(self) -> bool:
-        """Return True if all verification steps passed."""
+        """Return True if all verification steps passed or were skipped."""
         return all(
-            [
+            status in (VerificationStatus.PASSED, VerificationStatus.SKIPPED)
+            for status in [
                 self.operator_pod_installed,
                 self.operator_health,
                 self.operator_identity,
@@ -654,24 +667,24 @@ class OperatorVerifier:
                 port=OPERATOR_HEALTH_PORT,
             )
 
-    def verify_operator_health(self, operator_data: OperatorData) -> bool:
+    def verify_operator_health(self, operator_data: OperatorData) -> VerificationStatus:
         """Verify operator health using pre-fetched data."""
         if operator_data.health.is_healthy:
-            return True
+            return VerificationStatus.PASSED
         else:
             self.log.error(
                 f"Health check failed - HTTP {operator_data.health.status_code}"
             )
             if operator_data.health.response_text:
                 self.log.error(f"Response: {operator_data.health.response_text}")
-            return False
+            return VerificationStatus.FAILED
 
     def verify_operator_identity(
         self,
         operator_data: OperatorData,
         kubernetes_config: OpenAPIKubernetesConfig,
         cloud_provider: Optional[CloudProviders],
-    ) -> bool:
+    ) -> VerificationStatus:
         """Verify operator identity using pre-fetched config data."""
         # Validate kubernetes_config contents
         expected_identity = kubernetes_config.anyscale_operator_iam_identity
@@ -679,7 +692,7 @@ class OperatorVerifier:
             self.log.error(
                 "Missing 'anyscale_operator_iam_identity' in kubernetes config"
             )
-            return False
+            return VerificationStatus.FAILED
 
         # Validate config response
         if not operator_data.config.is_valid:
@@ -688,32 +701,34 @@ class OperatorVerifier:
             )
             if operator_data.config.response_text:
                 self.log.error(f"Response: {operator_data.config.response_text}")
-            return False
+            return VerificationStatus.FAILED
 
         # Extract actual identity from config
         if operator_data.config.config_data is None:
             self.log.error("Operator config data is None")
-            return False
+            return VerificationStatus.FAILED
 
         actual_identity = operator_data.config.config_data.get("iamIdentity")
         if not actual_identity:
             self.log.error("Operator config missing 'iamIdentity' field")
-            return False
+            return VerificationStatus.FAILED
 
         # Perform identity comparison
         if self._evaluate_identity_match(
             expected_identity, actual_identity, cloud_provider
         ):
+            # Get cloud provider string for display
+            provider_str = str(cloud_provider) if cloud_provider else "AWS"
             self.log.info(
-                f"AWS identity match: Role matches (Expected: {expected_identity})"
+                f"{provider_str} identity match: Expected identity matches (Expected: {expected_identity})"
             )
-            self.log.info("Expected IAM role matches actual assumed role")
-            return True
+            self.log.info("Expected identity matches actual identity")
+            return VerificationStatus.PASSED
         else:
             self.log.error("Operator identity mismatch")
             self.log.error(f"Expected: {expected_identity}")
             self.log.error(f"Actual: {actual_identity}")
-            return False
+            return VerificationStatus.FAILED
 
     @contextmanager
     def _port_forward_to_operator(self, pod_name: str):
@@ -980,8 +995,12 @@ class StorageVerifier:
 
     def verify_file_storage(
         self, file_storage: FileStorage, cloud_deployment: CloudDeployment
-    ) -> bool:
-        """Verify file storage configuration (non-functional checks only)."""
+    ) -> VerificationStatus:
+        """Verify file storage configuration (non-functional checks only).
+
+        Returns:
+            VerificationStatus enum value
+        """
         self.log.info("Verifying file storage configuration...")
         verification_results = []
 
@@ -1014,12 +1033,15 @@ class StorageVerifier:
                     f"Cloud provider API error while verifying file storage: {e}"
                 ) from e
 
-        # Return overall success
+        # Return overall status
         if verification_results:
-            return all(result for _, result in verification_results)
+            if all(result for _, result in verification_results):
+                return VerificationStatus.PASSED
+            else:
+                return VerificationStatus.FAILED
         else:
-            self.log.info("INFO: No file storage components found to verify")
-            return True
+            self.log.info("No file storage components found to verify")
+            return VerificationStatus.SKIPPED
 
     def _verify_csi_driver(self, driver_name: str) -> bool:
         """Check if CSI driver exists on cluster."""
@@ -1135,13 +1157,17 @@ class GatewayVerifier:
         self.config = k8s_config
         self.log = logger
 
-    def verify_gateway_support(self, operator_data: OperatorData) -> bool:
-        """Verify gateway support using pre-fetched config data."""
+    def verify_gateway_support(self, operator_data: OperatorData) -> VerificationStatus:
+        """Verify gateway support using pre-fetched config data.
+
+        Returns:
+            VerificationStatus enum value
+        """
         if not operator_data.config.is_valid:
-            self.log.warning(
+            self.log.info(
                 "Could not retrieve operator configuration - skipping gateway verification"
             )
-            return True
+            return VerificationStatus.SKIPPED
 
         # Extract gateway configuration from operator data
         gateway_config = GatewayConfig.from_operator_config(
@@ -1152,21 +1178,24 @@ class GatewayVerifier:
             self.log.info(
                 "Gateway support is not enabled - skipping gateway verification"
             )
-            return True
+            return VerificationStatus.SKIPPED
 
         if not gateway_config.requires_verification:
             self.log.error(
                 "Gateway is enabled but no gateway name found in operator configuration"
             )
-            return False
+            return VerificationStatus.FAILED
 
         # Verify gateway exists in cluster
         assert (
             gateway_config.name is not None
         )  # guaranteed by requires_verification check
-        return self._verify_gateway_exists(gateway_config.name)
+        if self._verify_gateway_exists(gateway_config.name):
+            return VerificationStatus.PASSED
+        else:
+            return VerificationStatus.FAILED
 
-    def verify_nginx_ingress(self) -> bool:
+    def verify_nginx_ingress(self) -> VerificationStatus:
         """Check for NGINX ingress controller (warning only)."""
         try:
             self.log.info("Checking for NGINX ingress controller...")
@@ -1182,7 +1211,7 @@ class GatewayVerifier:
                             f"PASSED: Found running NGINX ingress controller: {nginx_pod} "
                             f"(namespace: {config_dict['namespace']})"
                         )
-                        return True
+                        return VerificationStatus.PASSED
                     else:
                         pod_status = self.kubectl.get_pod_status(
                             nginx_pod, config_dict["namespace"]
@@ -1194,14 +1223,14 @@ class GatewayVerifier:
 
             # Try fallback search by name patterns
             if self._find_nginx_by_name_pattern():
-                return True
+                return VerificationStatus.PASSED
 
             # No NGINX ingress controller found
             self.log.warning("No NGINX ingress controller found")
             self.log.warning("This may impact ingress routing capabilities")
             self.log.warning("Available ingress controllers:")
             self._list_available_ingress_controllers()
-            return False
+            return VerificationStatus.FAILED
 
         except (KubectlError, ResourceNotFoundError) as e:
             self.log.warning(f"WARNING: Could not verify NGINX ingress controller: {e}")
@@ -1437,10 +1466,6 @@ class KubernetesCloudDeploymentVerifier:
             self.log.error(f"Data parsing error during verification: {e}")
             return False
 
-    def _passed_or_failed_str_from_bool(self, is_passing: bool) -> str:
-        """Return PASSED or FAILED string for verification results, matching VM verification format."""
-        return PASSED_STATUS if is_passing else FAILED_STATUS
-
     @contextmanager
     def _verification_step(self, step_name: str):
         """Context manager for verification steps that indents detailed output."""
@@ -1467,7 +1492,7 @@ class KubernetesCloudDeploymentVerifier:
         with self._verification_step("Finding operator pod"):
             try:
                 operator_pod = operator_verifier.find_operator_pod()
-                self.results.operator_pod_installed = True
+                self.results.operator_pod_installed = VerificationStatus.PASSED
             except OperatorPodNotFoundError as e:
                 self.log.error(
                     "Failed to find operator pod, please make sure the operator is running"
@@ -1490,56 +1515,47 @@ class KubernetesCloudDeploymentVerifier:
             self.results.operator_health = operator_verifier.verify_operator_health(
                 operator_data
             )
-            self.log.info(
-                f"Operator Health: {self._passed_or_failed_str_from_bool(self.results.operator_health)}"
-            )
+            self.log.info(f"Operator Health: {self.results.operator_health.value}")
 
             self.log.info("Verifying operator identity...")
             if cloud_deployment.kubernetes_config is None:
                 self.log.error(
                     "Kubernetes configuration is missing from cloud deployment"
                 )
-                self.results.operator_identity = False
+                self.results.operator_identity = VerificationStatus.FAILED
             else:
                 self.results.operator_identity = operator_verifier.verify_operator_identity(
                     operator_data,
                     cloud_deployment.kubernetes_config,
                     cloud_deployment.provider,
                 )
-            self.log.info(
-                f"Operator Identity: {self._passed_or_failed_str_from_bool(self.results.operator_identity)}"
-            )
+            self.log.info(f"Operator Identity: {self.results.operator_identity.value}")
 
         # Step 4: Check file storage
         with self._verification_step("Checking file storage"):
             if cloud_deployment.file_storage is None:
                 self.log.info(
-                    "INFO: No file storage configured - skipping file storage verification"
+                    "No file storage configured - skipping file storage verification"
                 )
-                self.results.file_storage = True
+                self.results.file_storage = VerificationStatus.SKIPPED
             else:
                 self.results.file_storage = storage_verifier.verify_file_storage(
                     cloud_deployment.file_storage, cloud_deployment
                 )
-            self.log.info(
-                f"File Storage: {self._passed_or_failed_str_from_bool(self.results.file_storage)}"
-            )
+
+            self.log.info(f"File Storage: {self.results.file_storage.value}")
 
         # Step 5: Verify gateway support
-        with self._verification_step("Verifying gateway support"):
+        with self._verification_step("Checking gateway support"):
             self.results.gateway_support = gateway_verifier.verify_gateway_support(
                 operator_data
             )
-            self.log.info(
-                f"Gateway Support: {self._passed_or_failed_str_from_bool(self.results.gateway_support)}"
-            )
+            self.log.info(f"Gateway Support: {self.results.gateway_support.value}")
 
         # Step 6: Check NGINX ingress (warning only)
         with self._verification_step("Checking NGINX ingress controller"):
             self.results.nginx_ingress = gateway_verifier.verify_nginx_ingress()
-            self.log.info(
-                f"NGINX Ingress: {self._passed_or_failed_str_from_bool(self.results.nginx_ingress)}"
-            )
+            self.log.info(f"NGINX Ingress: {self.results.nginx_ingress.value}")
 
         self._show_verification_summary()
 
@@ -1557,9 +1573,7 @@ class KubernetesCloudDeploymentVerifier:
         verification_result_summary = ["Verification result:"]
 
         for component, result in self.results.to_dict().items():
-            verification_result_summary.append(
-                f"{component}: {self._passed_or_failed_str_from_bool(result)}"
-            )
+            verification_result_summary.append(f"{component}: {result.value}")
 
         self.log.info("\n".join(verification_result_summary))
 

anyscale/controllers/workspace_controller.py

@@ -1,7 +1,7 @@
 import os
 import shlex
 import subprocess
-from typing import Any, List, Optional
+from typing import Any, Dict, List, Optional
 
 import click
 import tabulate
@@ -10,9 +10,19 @@ from anyscale.cli_logger import BlockLogger
 from anyscale.client.openapi_client.models.create_experimental_workspace import (
     CreateExperimentalWorkspace,
 )
+from anyscale.client.openapi_client.models.delete_resource_tags_request import (
+    DeleteResourceTagsRequest,
+)
 from anyscale.client.openapi_client.models.experimental_workspace import (
     ExperimentalWorkspace,
 )
+from anyscale.client.openapi_client.models.resource_tag_resource_type import (
+    ResourceTagResourceType,
+)
+from anyscale.client.openapi_client.models.upsert_resource_tags_request import (
+    UpsertResourceTagsRequest,
+)
+from anyscale.commands.util import flatten_tag_dict_to_api_list
 from anyscale.controllers.base_controller import BaseController
 from anyscale.feature_flags import FLAG_DEFAULT_WORKING_DIR_FOR_PROJ
 from anyscale.project_utils import get_default_project
@@ -84,13 +94,21 @@ class WorkspaceController(BaseController):
             )
         )
 
-    def list(self) -> None:
+    def list(self, tags_filter: Optional[Dict[str, List[str]]] = None) -> None:
         """
         prints a non-exhaustive tabular list of information about non-deleted workspaces.
         """
-        workspaces_data: List[
-            ExperimentalWorkspace
-        ] = self.api_client.list_workspaces_api_v2_experimental_workspaces_get().results
+        params = {}
+        if tags_filter:
+            api_tag_filter = flatten_tag_dict_to_api_list(tags_filter)
+            if api_tag_filter:
+                params["tag_filter"] = api_tag_filter
+
+        workspaces_data: List[ExperimentalWorkspace] = (
+            self.api_client.list_workspaces_api_v2_experimental_workspaces_get(
+                **params
+            ).results
+        )
 
         workspaces_table: List[List[Any]] = [
             [
@@ -109,6 +127,50 @@ class WorkspaceController(BaseController):
 
         print(f"Workspaces:\n{table}")
 
+    def _resolve_workspace_id(
+        self, *, workspace_id: Optional[str], name: Optional[str]
+    ) -> str:
+        if workspace_id:
+            return workspace_id
+        if not name:
+            raise click.ClickException("Provide either --id or --name for workspace.")
+        results = self.api_client.list_workspaces_api_v2_experimental_workspaces_get(
+            name=name
+        ).results
+        if len(results) == 0:
+            raise click.ClickException(f"No workspace with name '{name}' found.")
+        if len(results) > 1:
+            raise click.ClickException(
+                f"Multiple workspaces with name '{name}' found. Please use --id."
+            )
+        return results[0].id
+
+    def add_tags(
+        self,
+        *,
+        workspace_id: Optional[str] = None,
+        name: Optional[str] = None,
+        tags: Dict[str, str],
+    ) -> None:
+        wid = self._resolve_workspace_id(workspace_id=workspace_id, name=name)
+        req = UpsertResourceTagsRequest(
+            resource_type=ResourceTagResourceType.WORKSPACE, resource_id=wid, tags=tags,
+        )
+        self.api_client.upsert_resource_tags_api_v2_tags_resource_put(req)
+
+    def remove_tags(
+        self,
+        *,
+        workspace_id: Optional[str] = None,
+        name: Optional[str] = None,
+        keys: List[str],
+    ) -> None:
+        wid = self._resolve_workspace_id(workspace_id=workspace_id, name=name)
+        req = DeleteResourceTagsRequest(
+            resource_type=ResourceTagResourceType.WORKSPACE, resource_id=wid, keys=keys,
+        )
+        self.api_client.delete_resource_tags_api_v2_tags_resource_delete(req)
+
     def clone(self, workspace: ExperimentalWorkspace) -> None:
         dir_name = workspace.name
         os.makedirs(dir_name)

anyscale/job/_private/job_sdk.py

@@ -46,7 +46,8 @@ HA_JOB_STATE_TO_JOB_STATE = {
     HaJobStates.PENDING: JobState.STARTING,
     HaJobStates.AWAITING_CLUSTER_START: JobState.STARTING,
     HaJobStates.SUCCESS: JobState.SUCCEEDED,
-    HaJobStates.ERRORED: JobState.FAILED,
+    # ERRORED is a transient state that can transition to RESTARTING when retries remain.
+    HaJobStates.ERRORED: JobState.RUNNING,
     HaJobStates.TERMINATED: JobState.FAILED,
     HaJobStates.BROKEN: JobState.FAILED,
     HaJobStates.OUT_OF_RETRIES: JobState.FAILED,
@@ -280,6 +281,7 @@ class PrivateJobSDK(WorkloadSDK):
                 workspace_id=self.client.get_current_workspace_id(),
                 config=prod_job_config,
                 job_queue_config=job_queue_config,
+                tags=getattr(config, "tags", None),
             )
         )
 
@@ -438,7 +440,35 @@ class PrivateJobSDK(WorkloadSDK):
         self.logger.info(f"Job {job_model.id} is successfully archived.")
         return job_model.id
 
-    def wait(
+    def _stream_logs_for_job_run(
+        self, job_run_id: str, next_page_token: Optional[str] = None,
+    ) -> Optional[str]:
+        """Stream logs for a job run and return updated pagination state.
+
+        Args:
+            job_run_id: The ID of the job run to stream logs for
+            next_page_token: Token for fetching next page of logs
+
+        Returns:
+            next_page_token for the next iteration
+        """
+        try:
+            logs, next_page_token = self.client.stream_logs_for_job_run(
+                job_run_id=job_run_id, next_page_token=next_page_token,
+            )
+
+            # Print logs line by line
+            for line in logs.splitlines():
+                if line:  # Skip empty lines
+                    print(line)
+
+        except Exception as e:  # noqa: BLE001
+            # Don't fail if log streaming fails
+            self.logger.warning(f"Error streaming logs: {e}")
+
+        return next_page_token
+
+    def wait(  # noqa: PLR0912
         self,
         *,
         name: Optional[str] = None,
@@ -448,6 +478,7 @@ class PrivateJobSDK(WorkloadSDK):
         state: Union[str, JobState] = JobState.SUCCEEDED,
         timeout_s: float = 1800,
         interval_s: float = _POLLING_INTERVAL_SECONDS,
+        follow: bool = False,
     ):
         if not isinstance(timeout_s, (int, float)):
             raise TypeError("timeout_s must be a float")
@@ -471,6 +502,11 @@ class PrivateJobSDK(WorkloadSDK):
         self.logger.info(
             f"Waiting for job '{job_id_or_name}' to reach target state {state}, currently in state: {curr_state}"
         )
+
+        next_page_token = None
+        job_run_id = None
+        logs_started = False
+
         for _ in self.timer.poll(timeout_s=timeout_s, interval_s=interval_s):
             job_model = self._resolve_to_job_model(
                 name=name, job_id=job_id, cloud=cloud, project=project
@@ -483,6 +519,18 @@ class PrivateJobSDK(WorkloadSDK):
                 )
                 curr_state = new_state
 
+            # Stream logs if enabled and job has a job run
+            if follow and job_model.last_job_run_id:
+                if not logs_started:
+                    job_run_id = job_model.last_job_run_id
+                    self.logger.info(f"Starting log stream for job run {job_run_id}")
+                    logs_started = True
+
+                if job_run_id:
+                    next_page_token = self._stream_logs_for_job_run(
+                        job_run_id=job_run_id, next_page_token=next_page_token,
+                    )
+
             if curr_state == state:
                 self.logger.info(
                     f"Job '{job_id_or_name}' reached target state, exiting"

anyscale/job/commands.py

@@ -187,6 +187,7 @@ _WAIT_ARG_DOCSTRINGS = {
     "project": "Named project to use for the job. If not provided, the default project for the cloud will be used (or, if running in a workspace, the project of the workspace).",
     "state": "Target state of the job",
     "timeout_s": "Number of seconds to wait before timing out, this timeout will not affect job execution",
+    "follow": "Whether to follow the logs of the job. If True, the logs will be streamed to the console.",
 }
 
 
@@ -204,6 +205,7 @@ def wait(
     project: Optional[str] = None,
     state: Union[JobState, str] = JobState.SUCCEEDED,
     timeout_s: float = 1800,
+    follow: bool = False,
     _private_sdk: Optional[PrivateJobSDK] = None,
     **_kwargs: Dict[str, Any],
 ):
@@ -216,6 +218,7 @@ def wait(
         project=project,
         state=state,
         timeout_s=timeout_s,
+        follow=follow,
     )
 
 

anyscale/job/models.py

@@ -300,6 +300,9 @@ py_modules: # (Optional) A list of local directories or remote URIs that will be
 cloud: anyscale-prod # (Optional) The name of the Anyscale Cloud.
 project: my-project # (Optional) The name of the Anyscale Project.
 max_retries: 3 # (Optional) Maximum number of times the job will be retried before being marked failed. Defaults to `1`.
+tags:
+    team: mlops
+    purpose: training
 
 """
 
@@ -377,6 +380,19 @@ max_retries: 3 # (Optional) Maximum number of times the job will be retried befo
             if timeout_s < 0:
                 raise ValueError("'timeout_s' must be >= 0.")
 
+    tags: Optional[Dict[str, str]] = field(
+        default=None, metadata={"docstring": "Tags to associate with the job."},
+    )
+
+    def _validate_tags(self, tags: Optional[Dict[str, str]]):
+        if tags is None:
+            return
+        if not isinstance(tags, dict):
+            raise TypeError("'tags' must be a Dict[str, str].")
+        for k, v in tags.items():
+            if not isinstance(k, str) or not isinstance(v, str):
+                raise TypeError("'tags' must be a Dict[str, str].")
+
 
 class JobRunState(ModelEnum):
     """Current state of an individual job run."""

anyscale/job_queue/__init__.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 from anyscale._private.anyscale_client import AnyscaleClient
 from anyscale._private.models.model_base import ResultIterator
@@ -16,9 +16,15 @@ from anyscale.job_queue.commands import (
     _LIST_EXAMPLE,
     _STATUS_ARG_DOCSTRINGS,
     _STATUS_EXAMPLE,
+    _TAGS_ADD_ARG_DOCSTRINGS,
+    _TAGS_ADD_EXAMPLE,
+    _TAGS_REMOVE_ARG_DOCSTRINGS,
+    _TAGS_REMOVE_EXAMPLE,
     _UPDATE_ARG_DOCSTRINGS,
     _UPDATE_EXAMPLE,
+    add_tags,
     list,
+    remove_tags,
     status,
     update,
 )
@@ -49,6 +55,7 @@ class JobQueueSDK:
         cloud: Optional[str] = None,
         project: Optional[str] = None,
         cluster_status: Optional[SessionState] = None,
+        tags_filter: Optional[dict[str, List[str]]] = None,
         page_size: Optional[int] = None,
         max_items: Optional[int] = None,
         sorting_directives: Optional[List[JobQueueSortDirective]] = None,
@@ -61,6 +68,7 @@ class JobQueueSDK:
             cloud=cloud,
             project=project,
             cluster_status=cluster_status,
+            tags_filter=tags_filter,
             page_size=page_size,
             max_items=max_items,
             sorting_directives=sorting_directives,
@@ -87,3 +95,31 @@ class JobQueueSDK:
             max_concurrency=max_concurrency,
             idle_timeout_s=idle_timeout_s,
         )
+
+    @sdk_docs(doc_py_example=_TAGS_ADD_EXAMPLE, arg_docstrings=_TAGS_ADD_ARG_DOCSTRINGS)
+    def add_tags(  # noqa: F811
+        self,
+        *,
+        job_queue_id: Optional[str] = None,
+        name: Optional[str] = None,
+        tags: Dict[str, str],
+    ) -> None:
+        """Upsert (add/update) tag key/value pairs for a job queue."""
+        return self._private_sdk.add_tags(
+            job_queue_id=job_queue_id, name=name, tags=tags
+        )
+
+    @sdk_docs(
+        doc_py_example=_TAGS_REMOVE_EXAMPLE, arg_docstrings=_TAGS_REMOVE_ARG_DOCSTRINGS
+    )
+    def remove_tags(  # noqa: F811
+        self,
+        *,
+        job_queue_id: Optional[str] = None,
+        name: Optional[str] = None,
+        keys: List[str],
+    ) -> None:
+        """Remove tags by key from a job queue."""
+        return self._private_sdk.remove_tags(
+            job_queue_id=job_queue_id, name=name, keys=keys
+        )