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

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,12 +100,17 @@ 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)
+    def _get_datasource_connections(
+        self, datasource_item: DatasourceItem, req_options: Optional[RequestOptions] = None
+    ) -> list[ConnectionItem]:
+        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)
+        for connection in connections:
+            connection._datasource_id = datasource_item.id
+            connection._datasource_name = datasource_item.name
         return connections
 
     # Delete 1 datasource by id
@@ -113,9 +119,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 +158,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 +171,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,27 +180,25 @@ 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:
+    def refresh(self, datasource_item: DatasourceItem, incremental: bool = False) -> JobItem:
         id_ = getattr(datasource_item, "id", datasource_item)
-        url = "{0}/{1}/refresh".format(self.baseurl, id_)
-        empty_req = RequestFactory.Empty.empty_req()
-        server_response = self.post_request(url, empty_req)
+        url = f"{self.baseurl}/{id_}/refresh"
+        refresh_req = RequestFactory.Task.refresh_req(incremental)
+        server_response = self.post_request(url, refresh_req)
         new_job = JobItem.from_response(server_response.content, self.parent_srv.namespace)[0]
         return new_job
 
     @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 +207,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 +227,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,41 +251,40 @@ 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:
             raise TypeError("file should be a filepath or file object.")
 
+        # Construct the url with the defined mode
+        url = f"{self.baseurl}?datasourceType={file_extension}"
         if not mode or not hasattr(self.parent_srv.PublishMode, mode):
-            error = "Invalid mode defined."
+            error = f"Invalid mode defined: {mode}"
             raise ValueError(error)
-
-        # Construct the url with the defined mode
-        url = "{0}?datasourceType={1}".format(self.baseurl, file_extension)
-        if mode == self.parent_srv.PublishMode.Overwrite or mode == self.parent_srv.PublishMode.Append:
-            url += "&{0}=true".format(mode.lower())
+        else:
+            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 +312,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 +330,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 +359,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 +393,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 +416,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 +440,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 +450,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)
 

tableauserverclient/server/endpoint/endpoint.py

@@ -8,12 +8,9 @@ from xml.etree.ElementTree import ParseError
 from typing import (
     Any,
     Callable,
-    Dict,
     Generic,
-    List,
     Optional,
     TYPE_CHECKING,
-    Tuple,
     TypeVar,
     Union,
 )
@@ -22,6 +19,7 @@ from tableauserverclient.models.pagination_item import PaginationItem
 from tableauserverclient.server.request_options import RequestOptions
 
 from tableauserverclient.server.endpoint.exceptions import (
+    FailedSignInError,
     ServerResponseError,
     InternalServerError,
     NonXMLResponseError,
@@ -56,7 +54,7 @@ class Endpoint:
     async_response = None
 
     @staticmethod
-    def set_parameters(http_options, auth_token, content, content_type, parameters) -> Dict[str, Any]:
+    def set_parameters(http_options, auth_token, content, content_type, parameters) -> dict[str, Any]:
         parameters = parameters or {}
         parameters.update(http_options)
         if "headers" not in parameters:
@@ -82,7 +80,7 @@ class Endpoint:
             else:
                 # only set the TSC user agent if not already populated
                 _client_version: Optional[str] = get_versions()["version"]
-                parameters["headers"][USER_AGENT_HEADER] = "Tableau Server Client/{}".format(_client_version)
+                parameters["headers"][USER_AGENT_HEADER] = f"Tableau Server Client/{_client_version}"
 
         # result: parameters["headers"]["User-Agent"] is set
         # return explicitly for testing only
@@ -90,12 +88,12 @@ class Endpoint:
 
     def _blocking_request(self, method, url, parameters={}) -> Optional[Union["Response", Exception]]:
         response = None
-        logger.debug("[{}] Begin blocking request to {}".format(datetime.timestamp(), url))
+        logger.debug(f"[{datetime.timestamp()}] Begin blocking request to {url}")
         try:
             response = method(url, **parameters)
-            logger.debug("[{}] Call finished".format(datetime.timestamp()))
+            logger.debug(f"[{datetime.timestamp()}] Call finished")
         except Exception as e:
-            logger.debug("Error making request to server: {}".format(e))
+            logger.debug(f"Error making request to server: {e}")
             raise e
         return response
 
@@ -111,13 +109,13 @@ class Endpoint:
         content: Optional[bytes] = None,
         auth_token: Optional[str] = None,
         content_type: Optional[str] = None,
-        parameters: Optional[Dict[str, Any]] = None,
+        parameters: Optional[dict[str, Any]] = None,
     ) -> "Response":
         parameters = Endpoint.set_parameters(
             self.parent_srv.http_options, auth_token, content, content_type, parameters
         )
 
-        logger.debug("request method {}, url: {}".format(method.__name__, url))
+        logger.debug(f"request method {method.__name__}, url: {url}")
         if content:
             redacted = helpers.strings.redact_xml(content[:200])
             # this needs to be under a trace or something, it's a LOT
@@ -129,21 +127,21 @@ class Endpoint:
         server_response: Optional[Union["Response", Exception]] = self.send_request_while_show_progress_threaded(
             method, url, parameters, request_timeout
         )
-        logger.debug("[{}] Async request returned: received {}".format(datetime.timestamp(), server_response))
+        logger.debug(f"[{datetime.timestamp()}] Async request returned: received {server_response}")
         # is this blocking retry really necessary? I guess if it was just the threading messing it up?
         if server_response is None:
             logger.debug(server_response)
-            logger.debug("[{}] Async request failed: retrying".format(datetime.timestamp()))
+            logger.debug(f"[{datetime.timestamp()}] Async request failed: retrying")
             server_response = self._blocking_request(method, url, parameters)
         if server_response is None:
-            logger.debug("[{}] Request failed".format(datetime.timestamp()))
+            logger.debug(f"[{datetime.timestamp()}] Request failed")
             raise RuntimeError
         if isinstance(server_response, Exception):
             raise server_response
         self._check_status(server_response, url)
 
         loggable_response = self.log_response_safely(server_response)
-        logger.debug("Server response from {0}".format(url))
+        logger.debug(f"Server response from {url}")
         # uncomment the following to log full responses in debug mode
         # BE CAREFUL WHEN SHARING THESE RESULTS - MAY CONTAIN YOUR SENSITIVE DATA
         # logger.debug(loggable_response)
@@ -154,16 +152,16 @@ class Endpoint:
         return server_response
 
     def _check_status(self, server_response: "Response", url: Optional[str] = None):
-        logger.debug("Response status: {}".format(server_response))
+        logger.debug(f"Response status: {server_response}")
         if not hasattr(server_response, "status_code"):
-            raise EnvironmentError("Response is not a http response?")
+            raise OSError("Response is not a http response?")
         if server_response.status_code >= 500:
             raise InternalServerError(server_response, url)
         elif server_response.status_code not in Success_codes:
             try:
                 if server_response.status_code == 401:
                     # TODO: catch this in server.py and attempt to sign in again, in case it's a session expiry
-                    raise NotSignedInError(server_response.content, url)
+                    raise FailedSignInError.from_response(server_response.content, self.parent_srv.namespace, url)
 
                 raise ServerResponseError.from_response(server_response.content, self.parent_srv.namespace, url)
             except ParseError:
@@ -183,9 +181,9 @@ class Endpoint:
         # content-type is an octet-stream accomplishes the same goal without eagerly loading content.
         # This check is to determine if the response is a text response (xml or otherwise)
         # so that we do not attempt to log bytes and other binary data.
-        loggable_response = "Content type `{}`".format(content_type)
+        loggable_response = f"Content type `{content_type}`"
         if content_type == "application/octet-stream":
-            loggable_response = "A stream of type {} [Truncated File Contents]".format(content_type)
+            loggable_response = f"A stream of type {content_type} [Truncated File Contents]"
         elif server_response.encoding and len(server_response.content) > 0:
             loggable_response = helpers.strings.redact_xml(server_response.content.decode(server_response.encoding))
         return loggable_response
@@ -313,7 +311,7 @@ def parameter_added_in(**params: str) -> Callable[[Callable[Concatenate[E, P], R
             for p in params_to_check:
                 min_ver = Version(str(params[p]))
                 if server_ver < min_ver:
-                    error = "{!r} not available in {}, it will be ignored. Added in {}".format(p, server_ver, min_ver)
+                    error = f"{p!r} not available in {server_ver}, it will be ignored. Added in {min_ver}"
                     warnings.warn(error)
             return func(self, *args, **kwargs)
 
@@ -353,5 +351,5 @@ class QuerysetEndpoint(Endpoint, Generic[T]):
         return queryset
 
     @abc.abstractmethod
-    def get(self, request_options: Optional[RequestOptions] = None) -> Tuple[List[T], PaginationItem]:
+    def get(self, request_options: Optional[RequestOptions] = None) -> tuple[list[T], PaginationItem]:
         raise NotImplementedError(f".get has not been implemented for {self.__class__.__qualname__}")