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

tableauserverclient/server/endpoint/data_alert_endpoint.py

@@ -7,7 +7,7 @@ from tableauserverclient.models import DataAlertItem, PaginationItem, UserItem
 
 from tableauserverclient.helpers.logging import logger
 
-from typing import List, Optional, TYPE_CHECKING, Tuple, Union
+from typing import Optional, TYPE_CHECKING, Union
 
 
 if TYPE_CHECKING:
@@ -17,14 +17,14 @@ if TYPE_CHECKING:
 
 class DataAlerts(Endpoint):
     def __init__(self, parent_srv: "Server") -> None:
-        super(DataAlerts, self).__init__(parent_srv)
+        super().__init__(parent_srv)
 
     @property
     def baseurl(self) -> str:
-        return "{0}/sites/{1}/dataAlerts".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/dataAlerts"
 
     @api(version="3.2")
-    def get(self, req_options: Optional["RequestOptions"] = None) -> Tuple[List[DataAlertItem], PaginationItem]:
+    def get(self, req_options: Optional["RequestOptions"] = None) -> tuple[list[DataAlertItem], PaginationItem]:
         logger.info("Querying all dataAlerts on site")
         url = self.baseurl
         server_response = self.get_request(url, req_options)
@@ -38,8 +38,8 @@ class DataAlerts(Endpoint):
         if not dataAlert_id:
             error = "dataAlert ID undefined."
             raise ValueError(error)
-        logger.info("Querying single dataAlert (ID: {0})".format(dataAlert_id))
-        url = "{0}/{1}".format(self.baseurl, dataAlert_id)
+        logger.info(f"Querying single dataAlert (ID: {dataAlert_id})")
+        url = f"{self.baseurl}/{dataAlert_id}"
         server_response = self.get_request(url)
         return DataAlertItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
@@ -55,9 +55,9 @@ class DataAlerts(Endpoint):
             error = "Dataalert ID undefined."
             raise ValueError(error)
         # DELETE /api/api-version/sites/site-id/dataAlerts/data-alert-id/users/user-id
-        url = "{0}/{1}".format(self.baseurl, dataAlert_id)
+        url = f"{self.baseurl}/{dataAlert_id}"
         self.delete_request(url)
-        logger.info("Deleted single dataAlert (ID: {0})".format(dataAlert_id))
+        logger.info(f"Deleted single dataAlert (ID: {dataAlert_id})")
 
     @api(version="3.2")
     def delete_user_from_alert(self, dataAlert: Union[DataAlertItem, str], user: Union[UserItem, str]) -> None:
@@ -80,9 +80,9 @@ class DataAlerts(Endpoint):
             error = "User ID undefined."
             raise ValueError(error)
         # DELETE /api/api-version/sites/site-id/dataAlerts/data-alert-id/users/user-id
-        url = "{0}/{1}/users/{2}".format(self.baseurl, dataAlert_id, user_id)
+        url = f"{self.baseurl}/{dataAlert_id}/users/{user_id}"
         self.delete_request(url)
-        logger.info("Deleted User (ID {0}) from dataAlert (ID: {1})".format(user_id, dataAlert_id))
+        logger.info(f"Deleted User (ID {user_id}) from dataAlert (ID: {dataAlert_id})")
 
     @api(version="3.2")
     def add_user_to_alert(self, dataAlert_item: DataAlertItem, user: Union[UserItem, str]) -> UserItem:
@@ -98,10 +98,10 @@ class DataAlerts(Endpoint):
         if not user_id:
             error = "User ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}/users".format(self.baseurl, dataAlert_item.id)
+        url = f"{self.baseurl}/{dataAlert_item.id}/users"
         update_req = RequestFactory.DataAlert.add_user_to_alert(dataAlert_item, user_id)
         server_response = self.post_request(url, update_req)
-        logger.info("Added user (ID {0}) to dataAlert item (ID: {1})".format(user_id, dataAlert_item.id))
+        logger.info(f"Added user (ID {user_id}) to dataAlert item (ID: {dataAlert_item.id})")
         added_user = UserItem.from_response(server_response.content, self.parent_srv.namespace)[0]
         return added_user
 
@@ -111,9 +111,9 @@ class DataAlerts(Endpoint):
             error = "Dataalert item missing ID."
             raise MissingRequiredFieldError(error)
 
-        url = "{0}/{1}".format(self.baseurl, dataAlert_item.id)
+        url = f"{self.baseurl}/{dataAlert_item.id}"
         update_req = RequestFactory.DataAlert.update_req(dataAlert_item)
         server_response = self.put_request(url, update_req)
-        logger.info("Updated dataAlert item (ID: {0})".format(dataAlert_item.id))
+        logger.info(f"Updated dataAlert item (ID: {dataAlert_item.id})")
         updated_dataAlert = DataAlertItem.from_response(server_response.content, self.parent_srv.namespace)[0]
         return updated_dataAlert

tableauserverclient/server/endpoint/databases_endpoint.py

@@ -1,5 +1,6 @@
 import logging
-from typing import Union, Iterable, Set
+from typing import Union
+from collections.abc import Iterable
 
 from tableauserverclient.server.endpoint.default_permissions_endpoint import _DefaultPermissionsEndpoint
 from tableauserverclient.server.endpoint.dqw_endpoint import _DataQualityWarningEndpoint
@@ -15,7 +16,7 @@ from tableauserverclient.helpers.logging import logger
 
 class Databases(Endpoint, TaggingMixin):
     def __init__(self, parent_srv):
-        super(Databases, self).__init__(parent_srv)
+        super().__init__(parent_srv)
 
         self._permissions = _PermissionsEndpoint(parent_srv, lambda: self.baseurl)
         self._default_permissions = _DefaultPermissionsEndpoint(parent_srv, lambda: self.baseurl)
@@ -23,7 +24,7 @@ class Databases(Endpoint, TaggingMixin):
 
     @property
     def baseurl(self):
-        return "{0}/sites/{1}/databases".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/databases"
 
     @api(version="3.5")
     def get(self, req_options=None):
@@ -40,8 +41,8 @@ class Databases(Endpoint, TaggingMixin):
         if not database_id:
             error = "database ID undefined."
             raise ValueError(error)
-        logger.info("Querying single database (ID: {0})".format(database_id))
-        url = "{0}/{1}".format(self.baseurl, database_id)
+        logger.info(f"Querying single database (ID: {database_id})")
+        url = f"{self.baseurl}/{database_id}"
         server_response = self.get_request(url)
         return DatabaseItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
@@ -50,9 +51,9 @@ class Databases(Endpoint, TaggingMixin):
         if not database_id:
             error = "Database ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}".format(self.baseurl, database_id)
+        url = f"{self.baseurl}/{database_id}"
         self.delete_request(url)
-        logger.info("Deleted single database (ID: {0})".format(database_id))
+        logger.info(f"Deleted single database (ID: {database_id})")
 
     @api(version="3.5")
     def update(self, database_item):
@@ -60,10 +61,10 @@ class Databases(Endpoint, TaggingMixin):
             error = "Database item missing ID."
             raise MissingRequiredFieldError(error)
 
-        url = "{0}/{1}".format(self.baseurl, database_item.id)
+        url = f"{self.baseurl}/{database_item.id}"
         update_req = RequestFactory.Database.update_req(database_item)
         server_response = self.put_request(url, update_req)
-        logger.info("Updated database item (ID: {0})".format(database_item.id))
+        logger.info(f"Updated database item (ID: {database_item.id})")
         updated_database = DatabaseItem.from_response(server_response.content, self.parent_srv.namespace)[0]
         return updated_database
 
@@ -78,10 +79,10 @@ class Databases(Endpoint, TaggingMixin):
             return self._get_tables_for_database(database_item)
 
         database_item._set_tables(column_fetcher)
-        logger.info("Populated tables for database (ID: {0}".format(database_item.id))
+        logger.info(f"Populated tables for database (ID: {database_item.id}")
 
     def _get_tables_for_database(self, database_item):
-        url = "{0}/{1}/tables".format(self.baseurl, database_item.id)
+        url = f"{self.baseurl}/{database_item.id}/tables"
         server_response = self.get_request(url)
         tables = TableItem.from_response(server_response.content, self.parent_srv.namespace)
         return tables
@@ -127,7 +128,7 @@ class Databases(Endpoint, TaggingMixin):
         self._data_quality_warnings.clear(item)
 
     @api(version="3.9")
-    def add_tags(self, item: Union[DatabaseItem, str], tags: Iterable[str]) -> Set[str]:
+    def add_tags(self, item: Union[DatabaseItem, str], tags: Iterable[str]) -> set[str]:
         return super().add_tags(item, tags)
 
     @api(version="3.9")

tableauserverclient/server/endpoint/datasources_endpoint.py

@@ -6,7 +6,8 @@ import os
 
 from contextlib import closing
 from pathlib import Path
-from typing import Iterable, List, Mapping, Optional, Sequence, Set, Tuple, TYPE_CHECKING, Union
+from typing import Optional, TYPE_CHECKING, Union
+from collections.abc import Iterable, Mapping, Sequence
 
 from tableauserverclient.helpers.headers import fix_filename
 from tableauserverclient.server.query import QuerySet
@@ -22,7 +23,7 @@ from tableauserverclient.server.endpoint.exceptions import InternalServerError,
 from tableauserverclient.server.endpoint.permissions_endpoint import _PermissionsEndpoint
 from tableauserverclient.server.endpoint.resource_tagger import TaggingMixin
 
-from tableauserverclient.config import ALLOWED_FILE_EXTENSIONS, FILESIZE_LIMIT_MB, BYTES_PER_MB, config
+from tableauserverclient.config import ALLOWED_FILE_EXTENSIONS, BYTES_PER_MB, config
 from tableauserverclient.filesys_helpers import (
     make_download_path,
     get_file_type,
@@ -57,7 +58,7 @@ PathOrFileW = Union[FilePath, FileObjectW]
 
 class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]):
     def __init__(self, parent_srv: "Server") -> None:
-        super(Datasources, self).__init__(parent_srv)
+        super().__init__(parent_srv)
         self._permissions = _PermissionsEndpoint(parent_srv, lambda: self.baseurl)
         self._data_quality_warnings = _DataQualityWarningEndpoint(self.parent_srv, "datasource")
 
@@ -65,11 +66,11 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
 
     @property
     def baseurl(self) -> str:
-        return "{0}/sites/{1}/datasources".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/datasources"
 
     # Get all datasources
     @api(version="2.0")
-    def get(self, req_options: Optional[RequestOptions] = None) -> Tuple[List[DatasourceItem], PaginationItem]:
+    def get(self, req_options: Optional[RequestOptions] = None) -> tuple[list[DatasourceItem], PaginationItem]:
         logger.info("Querying all datasources on site")
         url = self.baseurl
         server_response = self.get_request(url, req_options)
@@ -83,8 +84,8 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
         if not datasource_id:
             error = "Datasource ID undefined."
             raise ValueError(error)
-        logger.info("Querying single datasource (ID: {0})".format(datasource_id))
-        url = "{0}/{1}".format(self.baseurl, datasource_id)
+        logger.info(f"Querying single datasource (ID: {datasource_id})")
+        url = f"{self.baseurl}/{datasource_id}"
         server_response = self.get_request(url)
         return DatasourceItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
@@ -99,10 +100,10 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
             return self._get_datasource_connections(datasource_item)
 
         datasource_item._set_connections(connections_fetcher)
-        logger.info("Populated connections for datasource (ID: {0})".format(datasource_item.id))
+        logger.info(f"Populated connections for datasource (ID: {datasource_item.id})")
 
     def _get_datasource_connections(self, datasource_item, req_options=None):
-        url = "{0}/{1}/connections".format(self.baseurl, datasource_item.id)
+        url = f"{self.baseurl}/{datasource_item.id}/connections"
         server_response = self.get_request(url, req_options)
         connections = ConnectionItem.from_response(server_response.content, self.parent_srv.namespace)
         return connections
@@ -113,9 +114,9 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
         if not datasource_id:
             error = "Datasource ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}".format(self.baseurl, datasource_id)
+        url = f"{self.baseurl}/{datasource_id}"
         self.delete_request(url)
-        logger.info("Deleted single datasource (ID: {0})".format(datasource_id))
+        logger.info(f"Deleted single datasource (ID: {datasource_id})")
 
     # Download 1 datasource by id
     @api(version="2.0")
@@ -152,11 +153,11 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
         self.update_tags(datasource_item)
 
         # Update the datasource itself
-        url = "{0}/{1}".format(self.baseurl, datasource_item.id)
+        url = f"{self.baseurl}/{datasource_item.id}"
 
         update_req = RequestFactory.Datasource.update_req(datasource_item)
         server_response = self.put_request(url, update_req)
-        logger.info("Updated datasource item (ID: {0})".format(datasource_item.id))
+        logger.info(f"Updated datasource item (ID: {datasource_item.id})")
         updated_datasource = copy.copy(datasource_item)
         return updated_datasource._parse_common_elements(server_response.content, self.parent_srv.namespace)
 
@@ -165,7 +166,7 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
     def update_connection(
         self, datasource_item: DatasourceItem, connection_item: ConnectionItem
     ) -> Optional[ConnectionItem]:
-        url = "{0}/{1}/connections/{2}".format(self.baseurl, datasource_item.id, connection_item.id)
+        url = f"{self.baseurl}/{datasource_item.id}/connections/{connection_item.id}"
 
         update_req = RequestFactory.Connection.update_req(connection_item)
         server_response = self.put_request(url, update_req)
@@ -174,18 +175,16 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
             return None
 
         if len(connections) > 1:
-            logger.debug("Multiple connections returned ({0})".format(len(connections)))
+            logger.debug(f"Multiple connections returned ({len(connections)})")
         connection = list(filter(lambda x: x.id == connection_item.id, connections))[0]
 
-        logger.info(
-            "Updated datasource item (ID: {0} & connection item {1}".format(datasource_item.id, connection_item.id)
-        )
+        logger.info(f"Updated datasource item (ID: {datasource_item.id} & connection item {connection_item.id}")
         return connection
 
     @api(version="2.8")
     def refresh(self, datasource_item: DatasourceItem) -> JobItem:
         id_ = getattr(datasource_item, "id", datasource_item)
-        url = "{0}/{1}/refresh".format(self.baseurl, id_)
+        url = f"{self.baseurl}/{id_}/refresh"
         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]
@@ -194,7 +193,7 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
     @api(version="3.5")
     def create_extract(self, datasource_item: DatasourceItem, encrypt: bool = False) -> JobItem:
         id_ = getattr(datasource_item, "id", datasource_item)
-        url = "{0}/{1}/createExtract?encrypt={2}".format(self.baseurl, id_, encrypt)
+        url = f"{self.baseurl}/{id_}/createExtract?encrypt={encrypt}"
         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]
@@ -203,7 +202,7 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
     @api(version="3.5")
     def delete_extract(self, datasource_item: DatasourceItem) -> None:
         id_ = getattr(datasource_item, "id", datasource_item)
-        url = "{0}/{1}/deleteExtract".format(self.baseurl, id_)
+        url = f"{self.baseurl}/{id_}/deleteExtract"
         empty_req = RequestFactory.Empty.empty_req()
         self.post_request(url, empty_req)
 
@@ -223,12 +222,12 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
         if isinstance(file, (os.PathLike, str)):
             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:]
             file_size = os.path.getsize(file)
-            logger.debug("Publishing file `{}`, size `{}`".format(filename, file_size))
+            logger.debug(f"Publishing file `{filename}`, size `{file_size}`")
             # If name is not defined, grab the name from the file to publish
             if not datasource_item.name:
                 datasource_item.name = os.path.splitext(filename)[0]
@@ -247,10 +246,10 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
             elif file_type == "xml":
                 file_extension = "tds"
             else:
-                error = "Unsupported file type {}".format(file_type)
+                error = f"Unsupported file type {file_type}"
                 raise ValueError(error)
 
-            filename = "{}.{}".format(datasource_item.name, file_extension)
+            filename = f"{datasource_item.name}.{file_extension}"
             file_size = get_file_object_size(file)
 
         else:
@@ -261,27 +260,27 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
             raise ValueError(error)
 
         # Construct the url with the defined mode
-        url = "{0}?datasourceType={1}".format(self.baseurl, file_extension)
+        url = f"{self.baseurl}?datasourceType={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"
 
         if as_job:
-            url += "&{0}=true".format("asJob")
+            url += "&{}=true".format("asJob")
 
         # Determine if chunking is required (64MB is the limit for single upload method)
-        if file_size >= FILESIZE_LIMIT_MB * BYTES_PER_MB:
+        if file_size >= config.FILESIZE_LIMIT_MB * BYTES_PER_MB:
             logger.info(
                 "Publishing {} to server with chunking method (datasource over {}MB, chunk size {}MB)".format(
-                    filename, FILESIZE_LIMIT_MB, config.CHUNK_SIZE_MB
+                    filename, config.FILESIZE_LIMIT_MB, config.CHUNK_SIZE_MB
                 )
             )
             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.Datasource.publish_req_chunked(
                 datasource_item, connection_credentials, connections
             )
         else:
-            logger.info("Publishing {0} to server".format(filename))
+            logger.info(f"Publishing {filename} to server")
 
             if isinstance(file, (Path, str)):
                 with open(file, "rb") as f:
@@ -309,11 +308,11 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
 
         if as_job:
             new_job = JobItem.from_response(server_response.content, self.parent_srv.namespace)[0]
-            logger.info("Published {0} (JOB_ID: {1}".format(filename, new_job.id))
+            logger.info(f"Published {filename} (JOB_ID: {new_job.id}")
             return new_job
         else:
             new_datasource = DatasourceItem.from_response(server_response.content, self.parent_srv.namespace)[0]
-            logger.info("Published {0} (ID: {1})".format(filename, new_datasource.id))
+            logger.info(f"Published {filename} (ID: {new_datasource.id})")
             return new_datasource
 
     @api(version="3.13")
@@ -327,23 +326,23 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
     ) -> JobItem:
         if isinstance(datasource_or_connection_item, DatasourceItem):
             datasource_id = datasource_or_connection_item.id
-            url = "{0}/{1}/data".format(self.baseurl, datasource_id)
+            url = f"{self.baseurl}/{datasource_id}/data"
         elif isinstance(datasource_or_connection_item, ConnectionItem):
             datasource_id = datasource_or_connection_item.datasource_id
             connection_id = datasource_or_connection_item.id
-            url = "{0}/{1}/connections/{2}/data".format(self.baseurl, datasource_id, connection_id)
+            url = f"{self.baseurl}/{datasource_id}/connections/{connection_id}/data"
         else:
             assert isinstance(datasource_or_connection_item, str)
-            url = "{0}/{1}/data".format(self.baseurl, datasource_or_connection_item)
+            url = f"{self.baseurl}/{datasource_or_connection_item}/data"
 
         if payload is not None:
             if not os.path.isfile(payload):
                 error = "File path does not lead to an existing file."
-                raise IOError(error)
+                raise OSError(error)
 
-            logger.info("Uploading {0} to server with chunking method for Update job".format(payload))
+            logger.info(f"Uploading {payload} to server with chunking method for Update job")
             upload_session_id = self.parent_srv.fileuploads.upload(payload)
-            url = "{0}?uploadSessionId={1}".format(url, upload_session_id)
+            url = f"{url}?uploadSessionId={upload_session_id}"
 
         json_request = json.dumps({"actions": actions})
         parameters = {"headers": {"requestid": request_id}}
@@ -356,7 +355,7 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
         self._permissions.populate(item)
 
     @api(version="2.0")
-    def update_permissions(self, item: DatasourceItem, permission_item: List["PermissionsRule"]) -> None:
+    def update_permissions(self, item: DatasourceItem, permission_item: list["PermissionsRule"]) -> None:
         self._permissions.update(item, permission_item)
 
     @api(version="2.0")
@@ -390,12 +389,12 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
             return self._get_datasource_revisions(datasource_item)
 
         datasource_item._set_revisions(revisions_fetcher)
-        logger.info("Populated revisions for datasource (ID: {0})".format(datasource_item.id))
+        logger.info(f"Populated revisions for datasource (ID: {datasource_item.id})")
 
     def _get_datasource_revisions(
         self, datasource_item: DatasourceItem, req_options: Optional["RequestOptions"] = None
-    ) -> List[RevisionItem]:
-        url = "{0}/{1}/revisions".format(self.baseurl, datasource_item.id)
+    ) -> list[RevisionItem]:
+        url = f"{self.baseurl}/{datasource_item.id}/revisions"
         server_response = self.get_request(url, req_options)
         revisions = RevisionItem.from_response(server_response.content, self.parent_srv.namespace, datasource_item)
         return revisions
@@ -413,9 +412,9 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
             error = "Datasource ID undefined."
             raise ValueError(error)
         if revision_number is None:
-            url = "{0}/{1}/content".format(self.baseurl, datasource_id)
+            url = f"{self.baseurl}/{datasource_id}/content"
         else:
-            url = "{0}/{1}/revisions/{2}/content".format(self.baseurl, datasource_id, revision_number)
+            url = f"{self.baseurl}/{datasource_id}/revisions/{revision_number}/content"
 
         if not include_extract:
             url += "?includeExtract=False"
@@ -437,9 +436,7 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
                         f.write(chunk)
                 return_path = os.path.abspath(download_path)
 
-        logger.info(
-            "Downloaded datasource revision {0} to {1} (ID: {2})".format(revision_number, return_path, datasource_id)
-        )
+        logger.info(f"Downloaded datasource revision {revision_number} to {return_path} (ID: {datasource_id})")
         return return_path
 
     @api(version="2.3")
@@ -449,19 +446,17 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
         url = "/".join([self.baseurl, datasource_id, "revisions", revision_number])
 
         self.delete_request(url)
-        logger.info(
-            "Deleted single datasource revision (ID: {0}) (Revision: {1})".format(datasource_id, revision_number)
-        )
+        logger.info(f"Deleted single datasource revision (ID: {datasource_id}) (Revision: {revision_number})")
 
     # a convenience method
     @api(version="2.8")
     def schedule_extract_refresh(
         self, schedule_id: str, item: DatasourceItem
-    ) -> List["AddResponse"]:  # actually should return a task
+    ) -> list["AddResponse"]:  # actually should return a task
         return self.parent_srv.schedules.add_to_schedule(schedule_id, datasource=item)
 
     @api(version="1.0")
-    def add_tags(self, item: Union[DatasourceItem, str], tags: Union[Iterable[str], str]) -> Set[str]:
+    def add_tags(self, item: Union[DatasourceItem, str], tags: Union[Iterable[str], str]) -> set[str]:
         return super().add_tags(item, tags)
 
     @api(version="1.0")

tableauserverclient/server/endpoint/default_permissions_endpoint.py

@@ -4,7 +4,8 @@ from .endpoint import Endpoint
 from .exceptions import MissingRequiredFieldError
 from tableauserverclient.server import RequestFactory
 from tableauserverclient.models import DatabaseItem, PermissionsRule, ProjectItem, plural_type, Resource
-from typing import TYPE_CHECKING, Callable, List, Optional, Sequence, Union
+from typing import TYPE_CHECKING, Callable, Optional, Union
+from collections.abc import Sequence
 
 if TYPE_CHECKING:
     from ..server import Server
@@ -25,7 +26,7 @@ class _DefaultPermissionsEndpoint(Endpoint):
     """
 
     def __init__(self, parent_srv: "Server", owner_baseurl: Callable[[], str]) -> None:
-        super(_DefaultPermissionsEndpoint, self).__init__(parent_srv)
+        super().__init__(parent_srv)
 
         # owner_baseurl is the baseurl of the parent, a project or database.
         # It MUST be a lambda since we don't know the full site URL until we sign in.
@@ -33,23 +34,25 @@ class _DefaultPermissionsEndpoint(Endpoint):
         self.owner_baseurl = owner_baseurl
 
     def __str__(self):
-        return "<DefaultPermissionsEndpoint {} [Flow, Datasource, Workbook, Lens]>".format(self.owner_baseurl())
+        return f"<DefaultPermissionsEndpoint {self.owner_baseurl()} [Flow, Datasource, Workbook, Lens]>"
 
     __repr__ = __str__
 
     def update_default_permissions(
-        self, resource: BaseItem, permissions: Sequence[PermissionsRule], content_type: Resource
-    ) -> List[PermissionsRule]:
-        url = "{0}/{1}/default-permissions/{2}".format(self.owner_baseurl(), resource.id, plural_type(content_type))
+        self, resource: BaseItem, permissions: Sequence[PermissionsRule], content_type: Union[Resource, str]
+    ) -> list[PermissionsRule]:
+        url = f"{self.owner_baseurl()}/{resource.id}/default-permissions/{plural_type(content_type)}"
         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 default {} permissions for resource {}".format(content_type, resource.id))
+        logger.info(f"Updated default {content_type} permissions for resource {resource.id}")
         logger.info(permissions)
 
         return permissions
 
-    def delete_default_permission(self, resource: BaseItem, rule: PermissionsRule, content_type: Resource) -> None:
+    def delete_default_permission(
+        self, resource: BaseItem, rule: PermissionsRule, content_type: Union[Resource, str]
+    ) -> None:
         for capability, mode in rule.capabilities.items():
             # Made readability better but line is too long, will make this look better
             url = (
@@ -65,29 +68,27 @@ class _DefaultPermissionsEndpoint(Endpoint):
                 )
             )
 
-            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_default_permissions(self, item: BaseItem, content_type: Resource) -> None:
+    def populate_default_permissions(self, item: BaseItem, content_type: Union[Resource, str]) -> None:
         if not item.id:
             error = "Server item is missing ID. Item must be retrieved from server first."
             raise MissingRequiredFieldError(error)
 
-        def permission_fetcher() -> List[PermissionsRule]:
+        def permission_fetcher() -> list[PermissionsRule]:
             return self._get_default_permissions(item, content_type)
 
         item._set_default_permissions(permission_fetcher, content_type)
-        logger.info("Populated default {0} permissions for item (ID: {1})".format(content_type, item.id))
+        logger.info(f"Populated default {content_type} permissions for item (ID: {item.id})")
 
     def _get_default_permissions(
-        self, item: BaseItem, content_type: Resource, req_options: Optional["RequestOptions"] = None
-    ) -> List[PermissionsRule]:
-        url = "{0}/{1}/default-permissions/{2}".format(self.owner_baseurl(), item.id, plural_type(content_type))
+        self, item: BaseItem, content_type: Union[Resource, str], req_options: Optional["RequestOptions"] = None
+    ) -> list[PermissionsRule]:
+        url = f"{self.owner_baseurl()}/{item.id}/default-permissions/{plural_type(content_type)}"
         server_response = self.get_request(url, req_options)
         permissions = PermissionsRule.from_response(server_response.content, self.parent_srv.namespace)
         logger.info({"content_type": content_type, "permissions": permissions})

tableauserverclient/server/endpoint/dqw_endpoint.py

@@ -10,35 +10,35 @@ from tableauserverclient.helpers.logging import logger
 
 class _DataQualityWarningEndpoint(Endpoint):
     def __init__(self, parent_srv, resource_type):
-        super(_DataQualityWarningEndpoint, self).__init__(parent_srv)
+        super().__init__(parent_srv)
         self.resource_type = resource_type
 
     @property
     def baseurl(self):
-        return "{0}/sites/{1}/dataQualityWarnings/{2}".format(
+        return "{}/sites/{}/dataQualityWarnings/{}".format(
             self.parent_srv.baseurl, self.parent_srv.site_id, self.resource_type
         )
 
     def add(self, resource, warning):
-        url = "{baseurl}/{content_luid}".format(baseurl=self.baseurl, content_luid=resource.id)
+        url = f"{self.baseurl}/{resource.id}"
         add_req = RequestFactory.DQW.add_req(warning)
         response = self.post_request(url, add_req)
         warnings = DQWItem.from_response(response.content, self.parent_srv.namespace)
-        logger.info("Added dqw for resource {0}".format(resource.id))
+        logger.info(f"Added dqw for resource {resource.id}")
 
         return warnings
 
     def update(self, resource, warning):
-        url = "{baseurl}/{content_luid}".format(baseurl=self.baseurl, content_luid=resource.id)
+        url = f"{self.baseurl}/{resource.id}"
         add_req = RequestFactory.DQW.update_req(warning)
         response = self.put_request(url, add_req)
         warnings = DQWItem.from_response(response.content, self.parent_srv.namespace)
-        logger.info("Added dqw for resource {0}".format(resource.id))
+        logger.info(f"Added dqw for resource {resource.id}")
 
         return warnings
 
     def clear(self, resource):
-        url = "{baseurl}/{content_luid}".format(baseurl=self.baseurl, content_luid=resource.id)
+        url = f"{self.baseurl}/{resource.id}"
         return self.delete_request(url)
 
     def populate(self, item):
@@ -50,10 +50,10 @@ class _DataQualityWarningEndpoint(Endpoint):
             return self._get_data_quality_warnings(item)
 
         item._set_data_quality_warnings(dqw_fetcher)
-        logger.info("Populated permissions for item (ID: {0})".format(item.id))
+        logger.info(f"Populated permissions for item (ID: {item.id})")
 
     def _get_data_quality_warnings(self, item, req_options=None):
-        url = "{baseurl}/{content_luid}".format(baseurl=self.baseurl, content_luid=item.id)
+        url = f"{self.baseurl}/{item.id}"
         server_response = self.get_request(url, req_options)
         dqws = DQWItem.from_response(server_response.content, self.parent_srv.namespace)