tableauserverclient 0.33__py3-none-any.whl → 0.34__py3-none-any.whl

tableauserverclient/server/endpoint/flows_endpoint.py

@@ -5,7 +5,8 @@ import logging
 import os
 from contextlib import closing
 from pathlib import Path
-from typing import Iterable, List, Optional, TYPE_CHECKING, Tuple, Union
+from typing import Optional, TYPE_CHECKING, Union
+from collections.abc import Iterable
 
 from tableauserverclient.helpers.headers import fix_filename
 
@@ -53,18 +54,18 @@ PathOrFileW = Union[FilePath, FileObjectW]
 
 class Flows(QuerysetEndpoint[FlowItem], TaggingMixin[FlowItem]):
     def __init__(self, parent_srv):
-        super(Flows, self).__init__(parent_srv)
+        super().__init__(parent_srv)
         self._resource_tagger = _ResourceTagger(parent_srv)
         self._permissions = _PermissionsEndpoint(parent_srv, lambda: self.baseurl)
         self._data_quality_warnings = _DataQualityWarningEndpoint(self.parent_srv, "flow")
 
     @property
     def baseurl(self) -> str:
-        return "{0}/sites/{1}/flows".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/flows"
 
     # Get all flows
     @api(version="3.3")
-    def get(self, req_options: Optional["RequestOptions"] = None) -> Tuple[List[FlowItem], PaginationItem]:
+    def get(self, req_options: Optional["RequestOptions"] = None) -> tuple[list[FlowItem], PaginationItem]:
         logger.info("Querying all flows on site")
         url = self.baseurl
         server_response = self.get_request(url, req_options)
@@ -78,8 +79,8 @@ class Flows(QuerysetEndpoint[FlowItem], TaggingMixin[FlowItem]):
         if not flow_id:
             error = "Flow ID undefined."
             raise ValueError(error)
-        logger.info("Querying single flow (ID: {0})".format(flow_id))
-        url = "{0}/{1}".format(self.baseurl, flow_id)
+        logger.info(f"Querying single flow (ID: {flow_id})")
+        url = f"{self.baseurl}/{flow_id}"
         server_response = self.get_request(url)
         return FlowItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
@@ -94,10 +95,10 @@ class Flows(QuerysetEndpoint[FlowItem], TaggingMixin[FlowItem]):
             return self._get_flow_connections(flow_item)
 
         flow_item._set_connections(connections_fetcher)
-        logger.info("Populated connections for flow (ID: {0})".format(flow_item.id))
+        logger.info(f"Populated connections for flow (ID: {flow_item.id})")
 
-    def _get_flow_connections(self, flow_item, req_options: Optional["RequestOptions"] = None) -> List[ConnectionItem]:
-        url = "{0}/{1}/connections".format(self.baseurl, flow_item.id)
+    def _get_flow_connections(self, flow_item, req_options: Optional["RequestOptions"] = None) -> list[ConnectionItem]:
+        url = f"{self.baseurl}/{flow_item.id}/connections"
         server_response = self.get_request(url, req_options)
         connections = ConnectionItem.from_response(server_response.content, self.parent_srv.namespace)
         return connections
@@ -108,9 +109,9 @@ class Flows(QuerysetEndpoint[FlowItem], TaggingMixin[FlowItem]):
         if not flow_id:
             error = "Flow ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}".format(self.baseurl, flow_id)
+        url = f"{self.baseurl}/{flow_id}"
         self.delete_request(url)
-        logger.info("Deleted single flow (ID: {0})".format(flow_id))
+        logger.info(f"Deleted single flow (ID: {flow_id})")
 
     # Download 1 flow by id
     @api(version="3.3")
@@ -118,7 +119,7 @@ class Flows(QuerysetEndpoint[FlowItem], TaggingMixin[FlowItem]):
         if not flow_id:
             error = "Flow ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}/content".format(self.baseurl, flow_id)
+        url = f"{self.baseurl}/{flow_id}/content"
 
         with closing(self.get_request(url, parameters={"stream": True})) as server_response:
             m = Message()
@@ -137,7 +138,7 @@ class Flows(QuerysetEndpoint[FlowItem], TaggingMixin[FlowItem]):
                         f.write(chunk)
                 return_path = os.path.abspath(download_path)
 
-        logger.info("Downloaded flow to {0} (ID: {1})".format(return_path, flow_id))
+        logger.info(f"Downloaded flow to {return_path} (ID: {flow_id})")
         return return_path
 
     # Update flow
@@ -150,28 +151,28 @@ class Flows(QuerysetEndpoint[FlowItem], TaggingMixin[FlowItem]):
         self._resource_tagger.update_tags(self.baseurl, flow_item)
 
         # Update the flow itself
-        url = "{0}/{1}".format(self.baseurl, flow_item.id)
+        url = f"{self.baseurl}/{flow_item.id}"
         update_req = RequestFactory.Flow.update_req(flow_item)
         server_response = self.put_request(url, update_req)
-        logger.info("Updated flow item (ID: {0})".format(flow_item.id))
+        logger.info(f"Updated flow item (ID: {flow_item.id})")
         updated_flow = copy.copy(flow_item)
         return updated_flow._parse_common_elements(server_response.content, self.parent_srv.namespace)
 
     # Update flow connections
     @api(version="3.3")
     def update_connection(self, flow_item: FlowItem, connection_item: ConnectionItem) -> ConnectionItem:
-        url = "{0}/{1}/connections/{2}".format(self.baseurl, flow_item.id, connection_item.id)
+        url = f"{self.baseurl}/{flow_item.id}/connections/{connection_item.id}"
 
         update_req = RequestFactory.Connection.update_req(connection_item)
         server_response = self.put_request(url, update_req)
         connection = ConnectionItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
-        logger.info("Updated flow item (ID: {0} & connection item {1}".format(flow_item.id, connection_item.id))
+        logger.info(f"Updated flow item (ID: {flow_item.id} & connection item {connection_item.id}")
         return connection
 
     @api(version="3.3")
     def refresh(self, flow_item: FlowItem) -> JobItem:
-        url = "{0}/{1}/run".format(self.baseurl, flow_item.id)
+        url = f"{self.baseurl}/{flow_item.id}/run"
         empty_req = RequestFactory.Empty.empty_req()
         server_response = self.post_request(url, empty_req)
         new_job = JobItem.from_response(server_response.content, self.parent_srv.namespace)[0]
@@ -180,7 +181,7 @@ class Flows(QuerysetEndpoint[FlowItem], TaggingMixin[FlowItem]):
     # Publish flow
     @api(version="3.3")
     def publish(
-        self, flow_item: FlowItem, file: PathOrFileR, mode: str, connections: Optional[List[ConnectionItem]] = None
+        self, flow_item: FlowItem, file: PathOrFileR, mode: str, connections: Optional[list[ConnectionItem]] = None
     ) -> FlowItem:
         if not mode or not hasattr(self.parent_srv.PublishMode, mode):
             error = "Invalid mode defined."
@@ -189,7 +190,7 @@ class Flows(QuerysetEndpoint[FlowItem], TaggingMixin[FlowItem]):
         if isinstance(file, (str, os.PathLike)):
             if not os.path.isfile(file):
                 error = "File path does not lead to an existing file."
-                raise IOError(error)
+                raise OSError(error)
 
             filename = os.path.basename(file)
             file_extension = os.path.splitext(filename)[1][1:]
@@ -213,30 +214,30 @@ class Flows(QuerysetEndpoint[FlowItem], TaggingMixin[FlowItem]):
             elif file_type == "xml":
                 file_extension = "tfl"
             else:
-                error = "Unsupported file type {}!".format(file_type)
+                error = f"Unsupported file type {file_type}!"
                 raise ValueError(error)
 
             # Generate filename for file object.
             # This is needed when publishing the flow in a single request
-            filename = "{}.{}".format(flow_item.name, file_extension)
+            filename = f"{flow_item.name}.{file_extension}"
             file_size = get_file_object_size(file)
 
         else:
             raise TypeError("file should be a filepath or file object.")
 
         # Construct the url with the defined mode
-        url = "{0}?flowType={1}".format(self.baseurl, file_extension)
+        url = f"{self.baseurl}?flowType={file_extension}"
         if mode == self.parent_srv.PublishMode.Overwrite or mode == self.parent_srv.PublishMode.Append:
-            url += "&{0}=true".format(mode.lower())
+            url += f"&{mode.lower()}=true"
 
         # Determine if chunking is required (64MB is the limit for single upload method)
         if file_size >= FILESIZE_LIMIT:
-            logger.info("Publishing {0} to server with chunking method (flow over 64MB)".format(filename))
+            logger.info(f"Publishing {filename} to server with chunking method (flow over 64MB)")
             upload_session_id = self.parent_srv.fileuploads.upload(file)
-            url = "{0}&uploadSessionId={1}".format(url, upload_session_id)
+            url = f"{url}&uploadSessionId={upload_session_id}"
             xml_request, content_type = RequestFactory.Flow.publish_req_chunked(flow_item, connections)
         else:
-            logger.info("Publishing {0} to server".format(filename))
+            logger.info(f"Publishing {filename} to server")
 
             if isinstance(file, (str, Path)):
                 with open(file, "rb") as f:
@@ -259,7 +260,7 @@ class Flows(QuerysetEndpoint[FlowItem], TaggingMixin[FlowItem]):
             raise err
         else:
             new_flow = FlowItem.from_response(server_response.content, self.parent_srv.namespace)[0]
-            logger.info("Published {0} (ID: {1})".format(filename, new_flow.id))
+            logger.info(f"Published {filename} (ID: {new_flow.id})")
             return new_flow
 
     @api(version="3.3")
@@ -294,7 +295,7 @@ class Flows(QuerysetEndpoint[FlowItem], TaggingMixin[FlowItem]):
     @api(version="3.3")
     def schedule_flow_run(
         self, schedule_id: str, item: FlowItem
-    ) -> List["AddResponse"]:  # actually should return a task
+    ) -> list["AddResponse"]:  # actually should return a task
         return self.parent_srv.schedules.add_to_schedule(schedule_id, flow=item)
 
     def filter(self, *invalid, page_size: Optional[int] = None, **kwargs) -> QuerySet[FlowItem]:

tableauserverclient/server/endpoint/groups_endpoint.py

@@ -8,7 +8,8 @@ from tableauserverclient.server.pager import Pager
 
 from tableauserverclient.helpers.logging import logger
 
-from typing import Iterable, List, Optional, TYPE_CHECKING, Tuple, Union
+from typing import Optional, TYPE_CHECKING, Union
+from collections.abc import Iterable
 
 from tableauserverclient.server.query import QuerySet
 
@@ -19,10 +20,10 @@ if TYPE_CHECKING:
 class Groups(QuerysetEndpoint[GroupItem]):
     @property
     def baseurl(self) -> str:
-        return "{0}/sites/{1}/groups".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/groups"
 
     @api(version="2.0")
-    def get(self, req_options: Optional["RequestOptions"] = None) -> Tuple[List[GroupItem], PaginationItem]:
+    def get(self, req_options: Optional["RequestOptions"] = None) -> tuple[list[GroupItem], PaginationItem]:
         """Gets all groups"""
         logger.info("Querying all groups on site")
         url = self.baseurl
@@ -50,12 +51,12 @@ class Groups(QuerysetEndpoint[GroupItem]):
 
     def _get_users_for_group(
         self, group_item: GroupItem, req_options: Optional["RequestOptions"] = None
-    ) -> Tuple[List[UserItem], PaginationItem]:
-        url = "{0}/{1}/users".format(self.baseurl, group_item.id)
+    ) -> tuple[list[UserItem], PaginationItem]:
+        url = f"{self.baseurl}/{group_item.id}/users"
         server_response = self.get_request(url, req_options)
         user_item = UserItem.from_response(server_response.content, self.parent_srv.namespace)
         pagination_item = PaginationItem.from_response(server_response.content, self.parent_srv.namespace)
-        logger.info("Populated users for group (ID: {0})".format(group_item.id))
+        logger.info(f"Populated users for group (ID: {group_item.id})")
         return user_item, pagination_item
 
     @api(version="2.0")
@@ -64,13 +65,13 @@ class Groups(QuerysetEndpoint[GroupItem]):
         if not group_id:
             error = "Group ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}".format(self.baseurl, group_id)
+        url = f"{self.baseurl}/{group_id}"
         self.delete_request(url)
-        logger.info("Deleted single group (ID: {0})".format(group_id))
+        logger.info(f"Deleted single group (ID: {group_id})")
 
     @api(version="2.0")
     def update(self, group_item: GroupItem, as_job: bool = False) -> Union[GroupItem, JobItem]:
-        url = "{0}/{1}".format(self.baseurl, group_item.id)
+        url = f"{self.baseurl}/{group_item.id}"
 
         if not group_item.id:
             error = "Group item missing ID."
@@ -83,7 +84,7 @@ class Groups(QuerysetEndpoint[GroupItem]):
 
         update_req = RequestFactory.Group.update_req(group_item)
         server_response = self.put_request(url, update_req)
-        logger.info("Updated group item (ID: {0})".format(group_item.id))
+        logger.info(f"Updated group item (ID: {group_item.id})")
         if as_job:
             return JobItem.from_response(server_response.content, self.parent_srv.namespace)[0]
         else:
@@ -118,9 +119,9 @@ class Groups(QuerysetEndpoint[GroupItem]):
         if not user_id:
             error = "User ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}/users/{2}".format(self.baseurl, group_item.id, user_id)
+        url = f"{self.baseurl}/{group_item.id}/users/{user_id}"
         self.delete_request(url)
-        logger.info("Removed user (id: {0}) from group (ID: {1})".format(user_id, group_item.id))
+        logger.info(f"Removed user (id: {user_id}) from group (ID: {group_item.id})")
 
     @api(version="3.21")
     def remove_users(self, group_item: GroupItem, users: Iterable[Union[str, UserItem]]) -> None:
@@ -132,7 +133,7 @@ class Groups(QuerysetEndpoint[GroupItem]):
         url = f"{self.baseurl}/{group_id}/users/remove"
         add_req = RequestFactory.Group.remove_users_req(users)
         _ = self.put_request(url, add_req)
-        logger.info("Removed users to group (ID: {0})".format(group_item.id))
+        logger.info(f"Removed users to group (ID: {group_item.id})")
         return None
 
     @api(version="2.0")
@@ -144,15 +145,15 @@ class Groups(QuerysetEndpoint[GroupItem]):
         if not user_id:
             error = "User ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}/users".format(self.baseurl, group_item.id)
+        url = f"{self.baseurl}/{group_item.id}/users"
         add_req = RequestFactory.Group.add_user_req(user_id)
         server_response = self.post_request(url, add_req)
         user = UserItem.from_response(server_response.content, self.parent_srv.namespace).pop()
-        logger.info("Added user (id: {0}) to group (ID: {1})".format(user_id, group_item.id))
+        logger.info(f"Added user (id: {user_id}) to group (ID: {group_item.id})")
         return user
 
     @api(version="3.21")
-    def add_users(self, group_item: GroupItem, users: Iterable[Union[str, UserItem]]) -> List[UserItem]:
+    def add_users(self, group_item: GroupItem, users: Iterable[Union[str, UserItem]]) -> list[UserItem]:
         """Adds multiple users to 1 group"""
         group_id = group_item.id if hasattr(group_item, "id") else group_item
         if not isinstance(group_id, str):
@@ -162,7 +163,7 @@ class Groups(QuerysetEndpoint[GroupItem]):
         add_req = RequestFactory.Group.add_users_req(users)
         server_response = self.post_request(url, add_req)
         users = UserItem.from_response(server_response.content, self.parent_srv.namespace)
-        logger.info("Added users to group (ID: {0})".format(group_item.id))
+        logger.info(f"Added users to group (ID: {group_item.id})")
         return users
 
     def filter(self, *invalid, page_size: Optional[int] = None, **kwargs) -> QuerySet[GroupItem]:

tableauserverclient/server/endpoint/groupsets_endpoint.py

@@ -1,4 +1,4 @@
-from typing import List, Literal, Optional, Tuple, TYPE_CHECKING, Union
+from typing import Literal, Optional, TYPE_CHECKING, Union
 
 from tableauserverclient.helpers.logging import logger
 from tableauserverclient.models.group_item import GroupItem
@@ -27,7 +27,7 @@ class GroupSets(QuerysetEndpoint[GroupSetItem]):
         self,
         request_options: Optional[RequestOptions] = None,
         result_level: Optional[Literal["members", "local"]] = None,
-    ) -> Tuple[List[GroupSetItem], PaginationItem]:
+    ) -> tuple[list[GroupSetItem], PaginationItem]:
         logger.info("Querying all group sets on site")
         url = self.baseurl
         if result_level:

tableauserverclient/server/endpoint/jobs_endpoint.py

@@ -11,24 +11,24 @@ from tableauserverclient.exponential_backoff import ExponentialBackoffTimer
 
 from tableauserverclient.helpers.logging import logger
 
-from typing import List, Optional, Tuple, Union
+from typing import Optional, Union
 
 
 class Jobs(QuerysetEndpoint[BackgroundJobItem]):
     @property
     def baseurl(self):
-        return "{0}/sites/{1}/jobs".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/jobs"
 
     @overload  # type: ignore[override]
     def get(self: Self, job_id: str, req_options: Optional[RequestOptionsBase] = None) -> JobItem:  # type: ignore[override]
         ...
 
     @overload  # type: ignore[override]
-    def get(self: Self, job_id: RequestOptionsBase, req_options: None) -> Tuple[List[BackgroundJobItem], PaginationItem]:  # type: ignore[override]
+    def get(self: Self, job_id: RequestOptionsBase, req_options: None) -> tuple[list[BackgroundJobItem], PaginationItem]:  # type: ignore[override]
         ...
 
     @overload  # type: ignore[override]
-    def get(self: Self, job_id: None, req_options: Optional[RequestOptionsBase]) -> Tuple[List[BackgroundJobItem], PaginationItem]:  # type: ignore[override]
+    def get(self: Self, job_id: None, req_options: Optional[RequestOptionsBase]) -> tuple[list[BackgroundJobItem], PaginationItem]:  # type: ignore[override]
         ...
 
     @api(version="2.6")
@@ -53,13 +53,13 @@ class Jobs(QuerysetEndpoint[BackgroundJobItem]):
         if isinstance(job_id, JobItem):
             job_id = job_id.id
         assert isinstance(job_id, str)
-        url = "{0}/{1}".format(self.baseurl, job_id)
+        url = f"{self.baseurl}/{job_id}"
         return self.put_request(url)
 
     @api(version="2.6")
     def get_by_id(self, job_id: str) -> JobItem:
         logger.info("Query for information about job " + job_id)
-        url = "{0}/{1}".format(self.baseurl, job_id)
+        url = f"{self.baseurl}/{job_id}"
         server_response = self.get_request(url)
         new_job = JobItem.from_response(server_response.content, self.parent_srv.namespace)[0]
         return new_job
@@ -77,7 +77,7 @@ class Jobs(QuerysetEndpoint[BackgroundJobItem]):
             job = self.get_by_id(job_id)
             logger.debug(f"\tJob {job_id} progress={job.progress}")
 
-        logger.info("Job {} Completed: Finish Code: {} - Notes:{}".format(job_id, job.finish_code, job.notes))
+        logger.info(f"Job {job_id} Completed: Finish Code: {job.finish_code} - Notes:{job.notes}")
 
         if job.finish_code == JobItem.FinishCode.Success:
             return job

tableauserverclient/server/endpoint/linked_tasks_endpoint.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Tuple, Union
+from typing import Optional, Union
 
 from tableauserverclient.helpers.logging import logger
 from tableauserverclient.models.linked_tasks_item import LinkedTaskItem, LinkedTaskJobItem
@@ -18,7 +18,7 @@ class LinkedTasks(QuerysetEndpoint[LinkedTaskItem]):
         return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/tasks/linked"
 
     @api(version="3.15")
-    def get(self, req_options: Optional["RequestOptions"] = None) -> Tuple[List[LinkedTaskItem], PaginationItem]:
+    def get(self, req_options: Optional["RequestOptions"] = None) -> tuple[list[LinkedTaskItem], PaginationItem]:
         logger.info("Querying all linked tasks on site")
         url = self.baseurl
         server_response = self.get_request(url, req_options)

tableauserverclient/server/endpoint/metadata_endpoint.py

@@ -50,11 +50,11 @@ def get_page_info(result):
 class Metadata(Endpoint):
     @property
     def baseurl(self):
-        return "{0}/api/metadata/graphql".format(self.parent_srv.server_address)
+        return f"{self.parent_srv.server_address}/api/metadata/graphql"
 
     @property
     def control_baseurl(self):
-        return "{0}/api/metadata/v1/control".format(self.parent_srv.server_address)
+        return f"{self.parent_srv.server_address}/api/metadata/v1/control"
 
     @api("3.5")
     def query(self, query, variables=None, abort_on_error=False, parameters=None):

tableauserverclient/server/endpoint/metrics_endpoint.py

@@ -8,7 +8,7 @@ from tableauserverclient.models import MetricItem, PaginationItem
 
 import logging
 
-from typing import List, Optional, TYPE_CHECKING, Tuple
+from typing import Optional, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from ..request_options import RequestOptions
@@ -20,18 +20,18 @@ from tableauserverclient.helpers.logging import logger
 
 class Metrics(QuerysetEndpoint[MetricItem]):
     def __init__(self, parent_srv: "Server") -> None:
-        super(Metrics, self).__init__(parent_srv)
+        super().__init__(parent_srv)
         self._resource_tagger = _ResourceTagger(parent_srv)
         self._permissions = _PermissionsEndpoint(parent_srv, lambda: self.baseurl)
         self._data_quality_warnings = _DataQualityWarningEndpoint(self.parent_srv, "metric")
 
     @property
     def baseurl(self) -> str:
-        return "{0}/sites/{1}/metrics".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/metrics"
 
     # Get all metrics
     @api(version="3.9")
-    def get(self, req_options: Optional["RequestOptions"] = None) -> Tuple[List[MetricItem], PaginationItem]:
+    def get(self, req_options: Optional["RequestOptions"] = None) -> tuple[list[MetricItem], PaginationItem]:
         logger.info("Querying all metrics on site")
         url = self.baseurl
         server_response = self.get_request(url, req_options)
@@ -45,8 +45,8 @@ class Metrics(QuerysetEndpoint[MetricItem]):
         if not metric_id:
             error = "Metric ID undefined."
             raise ValueError(error)
-        logger.info("Querying single metric (ID: {0})".format(metric_id))
-        url = "{0}/{1}".format(self.baseurl, metric_id)
+        logger.info(f"Querying single metric (ID: {metric_id})")
+        url = f"{self.baseurl}/{metric_id}"
         server_response = self.get_request(url)
         return MetricItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
@@ -56,9 +56,9 @@ class Metrics(QuerysetEndpoint[MetricItem]):
         if not metric_id:
             error = "Metric ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}".format(self.baseurl, metric_id)
+        url = f"{self.baseurl}/{metric_id}"
         self.delete_request(url)
-        logger.info("Deleted single metric (ID: {0})".format(metric_id))
+        logger.info(f"Deleted single metric (ID: {metric_id})")
 
     # Update metric
     @api(version="3.9")
@@ -70,8 +70,8 @@ class Metrics(QuerysetEndpoint[MetricItem]):
         self._resource_tagger.update_tags(self.baseurl, metric_item)
 
         # Update the metric itself
-        url = "{0}/{1}".format(self.baseurl, metric_item.id)
+        url = f"{self.baseurl}/{metric_item.id}"
         update_req = RequestFactory.Metric.update_req(metric_item)
         server_response = self.put_request(url, update_req)
-        logger.info("Updated metric item (ID: {0})".format(metric_item.id))
+        logger.info(f"Updated metric item (ID: {metric_item.id})")
         return MetricItem.from_response(server_response.content, self.parent_srv.namespace)[0]

tableauserverclient/server/endpoint/permissions_endpoint.py

@@ -6,7 +6,7 @@ from tableauserverclient.models import TableauItem, PermissionsRule
 from .endpoint import Endpoint
 from .exceptions import MissingRequiredFieldError
 
-from typing import Callable, TYPE_CHECKING, List, Optional, Union
+from typing import Callable, TYPE_CHECKING, Optional, Union
 
 from tableauserverclient.helpers.logging import logger
 
@@ -25,7 +25,7 @@ class _PermissionsEndpoint(Endpoint):
     """
 
     def __init__(self, parent_srv: "Server", owner_baseurl: Callable[[], str]) -> None:
-        super(_PermissionsEndpoint, self).__init__(parent_srv)
+        super().__init__(parent_srv)
 
         # owner_baseurl is the baseurl of the parent.  The MUST be a lambda
         # since we don't know the full site URL until we sign in.  If
@@ -33,18 +33,18 @@ class _PermissionsEndpoint(Endpoint):
         self.owner_baseurl = owner_baseurl
 
     def __str__(self):
-        return "<PermissionsEndpoint baseurl={}>".format(self.owner_baseurl)
+        return f"<PermissionsEndpoint baseurl={self.owner_baseurl}>"
 
-    def update(self, resource: TableauItem, permissions: List[PermissionsRule]) -> List[PermissionsRule]:
-        url = "{0}/{1}/permissions".format(self.owner_baseurl(), resource.id)
+    def update(self, resource: TableauItem, permissions: list[PermissionsRule]) -> list[PermissionsRule]:
+        url = f"{self.owner_baseurl()}/{resource.id}/permissions"
         update_req = RequestFactory.Permission.add_req(permissions)
         response = self.put_request(url, update_req)
         permissions = PermissionsRule.from_response(response.content, self.parent_srv.namespace)
-        logger.info("Updated permissions for resource {0}: {1}".format(resource.id, permissions))
+        logger.info(f"Updated permissions for resource {resource.id}: {permissions}")
 
         return permissions
 
-    def delete(self, resource: TableauItem, rules: Union[PermissionsRule, List[PermissionsRule]]):
+    def delete(self, resource: TableauItem, rules: Union[PermissionsRule, list[PermissionsRule]]):
         # Delete is the only endpoint that doesn't take a list of rules
         # so let's fake it to keep it consistent
         # TODO that means we need error handling around the call
@@ -54,7 +54,7 @@ class _PermissionsEndpoint(Endpoint):
         for rule in rules:
             for capability, mode in rule.capabilities.items():
                 "/permissions/groups/group-id/capability-name/capability-mode"
-                url = "{0}/{1}/permissions/{2}/{3}/{4}/{5}".format(
+                url = "{}/{}/permissions/{}/{}/{}/{}".format(
                     self.owner_baseurl(),
                     resource.id,
                     rule.grantee.tag_name + "s",
@@ -63,13 +63,11 @@ class _PermissionsEndpoint(Endpoint):
                     mode,
                 )
 
-                logger.debug("Removing {0} permission for capability {1}".format(mode, capability))
+                logger.debug(f"Removing {mode} permission for capability {capability}")
 
                 self.delete_request(url)
 
-            logger.info(
-                "Deleted permission for {0} {1} item {2}".format(rule.grantee.tag_name, rule.grantee.id, resource.id)
-            )
+            logger.info(f"Deleted permission for {rule.grantee.tag_name} {rule.grantee.id} item {resource.id}")
 
     def populate(self, item: TableauItem):
         if not item.id:
@@ -80,12 +78,12 @@ class _PermissionsEndpoint(Endpoint):
             return self._get_permissions(item)
 
         item._set_permissions(permission_fetcher)
-        logger.info("Populated permissions for item (ID: {0})".format(item.id))
+        logger.info(f"Populated permissions for item (ID: {item.id})")
 
     def _get_permissions(self, item: TableauItem, req_options: Optional["RequestOptions"] = None):
-        url = "{0}/{1}/permissions".format(self.owner_baseurl(), item.id)
+        url = f"{self.owner_baseurl()}/{item.id}/permissions"
         server_response = self.get_request(url, req_options)
         permissions = PermissionsRule.from_response(server_response.content, self.parent_srv.namespace)
-        logger.info("Permissions for resource {0}: {1}".format(item.id, permissions))
+        logger.info(f"Permissions for resource {item.id}: {permissions}")
 
         return permissions