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

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__}")

tableauserverclient/server/endpoint/exceptions.py

@@ -1,24 +1,31 @@
 from defusedxml.ElementTree import fromstring
-from typing import Optional
+from typing import Mapping, Optional, TypeVar
+
+
+def split_pascal_case(s: str) -> str:
+    return "".join([f" {c}" if c.isupper() else c for c in s]).strip()
 
 
 class TableauError(Exception):
     pass
 
 
-class ServerResponseError(TableauError):
-    def __init__(self, code, summary, detail, url=None):
+T = TypeVar("T")
+
+
+class XMLError(TableauError):
+    def __init__(self, code: str, summary: str, detail: str, url: Optional[str] = None) -> None:
         self.code = code
         self.summary = summary
         self.detail = detail
         self.url = url
-        super(ServerResponseError, self).__init__(str(self))
+        super().__init__(str(self))
 
     def __str__(self):
-        return "\n\n\t{0}: {1}\n\t\t{2}".format(self.code, self.summary, self.detail)
+        return f"\n\n\t{self.code}: {self.summary}\n\t\t{self.detail}"
 
     @classmethod
-    def from_response(cls, resp, ns, url=None):
+    def from_response(cls, resp, ns, url):
         # Check elements exist before .text
         parsed_response = fromstring(resp)
         try:
@@ -33,6 +40,10 @@ class ServerResponseError(TableauError):
         return error_response
 
 
+class ServerResponseError(XMLError):
+    pass
+
+
 class InternalServerError(TableauError):
     def __init__(self, server_response, request_url: Optional[str] = None):
         self.code = server_response.status_code
@@ -40,7 +51,7 @@ class InternalServerError(TableauError):
         self.url = request_url or "server"
 
     def __str__(self):
-        return "\n\nInternal error {0} at {1}\n{2}".format(self.code, self.url, self.content)
+        return f"\n\nInternal error {self.code} at {self.url}\n{self.content}"
 
 
 class MissingRequiredFieldError(TableauError):
@@ -51,6 +62,11 @@ class NotSignedInError(TableauError):
     pass
 
 
+class FailedSignInError(XMLError, NotSignedInError):
+    def __str__(self):
+        return f"{split_pascal_case(self.__class__.__name__)}: {super().__str__()}"
+
+
 class ItemTypeNotAllowed(TableauError):
     pass
 

tableauserverclient/server/endpoint/favorites_endpoint.py

@@ -20,13 +20,13 @@ from typing import Optional
 class Favorites(Endpoint):
     @property
     def baseurl(self) -> str:
-        return "{0}/sites/{1}/favorites".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/favorites"
 
     # Gets all favorites
     @api(version="2.5")
     def get(self, user_item: UserItem, req_options: Optional[RequestOptions] = None) -> None:
-        logger.info("Querying all favorites for user {0}".format(user_item.name))
-        url = "{0}/{1}".format(self.baseurl, user_item.id)
+        logger.info(f"Querying all favorites for user {user_item.name}")
+        url = f"{self.baseurl}/{user_item.id}"
         server_response = self.get_request(url, req_options)
         user_item._favorites = FavoriteItem.from_response(server_response.content, self.parent_srv.namespace)
 
@@ -34,53 +34,53 @@ class Favorites(Endpoint):
 
     @api(version="3.15")
     def add_favorite(self, user_item: UserItem, content_type: str, item: TableauItem) -> "Response":
-        url = "{0}/{1}".format(self.baseurl, user_item.id)
+        url = f"{self.baseurl}/{user_item.id}"
         add_req = RequestFactory.Favorite.add_request(item.id, content_type, item.name)
         server_response = self.put_request(url, add_req)
-        logger.info("Favorited {0} for user (ID: {1})".format(item.name, user_item.id))
+        logger.info(f"Favorited {item.name} for user (ID: {user_item.id})")
         return server_response
 
     @api(version="2.0")
     def add_favorite_workbook(self, user_item: UserItem, workbook_item: WorkbookItem) -> None:
-        url = "{0}/{1}".format(self.baseurl, user_item.id)
+        url = f"{self.baseurl}/{user_item.id}"
         add_req = RequestFactory.Favorite.add_workbook_req(workbook_item.id, workbook_item.name)
         server_response = self.put_request(url, add_req)
-        logger.info("Favorited {0} for user (ID: {1})".format(workbook_item.name, user_item.id))
+        logger.info(f"Favorited {workbook_item.name} for user (ID: {user_item.id})")
 
     @api(version="2.0")
     def add_favorite_view(self, user_item: UserItem, view_item: ViewItem) -> None:
-        url = "{0}/{1}".format(self.baseurl, user_item.id)
+        url = f"{self.baseurl}/{user_item.id}"
         add_req = RequestFactory.Favorite.add_view_req(view_item.id, view_item.name)
         server_response = self.put_request(url, add_req)
-        logger.info("Favorited {0} for user (ID: {1})".format(view_item.name, user_item.id))
+        logger.info(f"Favorited {view_item.name} for user (ID: {user_item.id})")
 
     @api(version="2.3")
     def add_favorite_datasource(self, user_item: UserItem, datasource_item: DatasourceItem) -> None:
-        url = "{0}/{1}".format(self.baseurl, user_item.id)
+        url = f"{self.baseurl}/{user_item.id}"
         add_req = RequestFactory.Favorite.add_datasource_req(datasource_item.id, datasource_item.name)
         server_response = self.put_request(url, add_req)
-        logger.info("Favorited {0} for user (ID: {1})".format(datasource_item.name, user_item.id))
+        logger.info(f"Favorited {datasource_item.name} for user (ID: {user_item.id})")
 
     @api(version="3.1")
     def add_favorite_project(self, user_item: UserItem, project_item: ProjectItem) -> None:
-        url = "{0}/{1}".format(self.baseurl, user_item.id)
+        url = f"{self.baseurl}/{user_item.id}"
         add_req = RequestFactory.Favorite.add_project_req(project_item.id, project_item.name)
         server_response = self.put_request(url, add_req)
-        logger.info("Favorited {0} for user (ID: {1})".format(project_item.name, user_item.id))
+        logger.info(f"Favorited {project_item.name} for user (ID: {user_item.id})")
 
     @api(version="3.3")
     def add_favorite_flow(self, user_item: UserItem, flow_item: FlowItem) -> None:
-        url = "{0}/{1}".format(self.baseurl, user_item.id)
+        url = f"{self.baseurl}/{user_item.id}"
         add_req = RequestFactory.Favorite.add_flow_req(flow_item.id, flow_item.name)
         server_response = self.put_request(url, add_req)
-        logger.info("Favorited {0} for user (ID: {1})".format(flow_item.name, user_item.id))
+        logger.info(f"Favorited {flow_item.name} for user (ID: {user_item.id})")
 
     @api(version="3.3")
     def add_favorite_metric(self, user_item: UserItem, metric_item: MetricItem) -> None:
-        url = "{0}/{1}".format(self.baseurl, user_item.id)
+        url = f"{self.baseurl}/{user_item.id}"
         add_req = RequestFactory.Favorite.add_request(metric_item.id, Resource.Metric, metric_item.name)
         server_response = self.put_request(url, add_req)
-        logger.info("Favorited metric {0} for user (ID: {1})".format(metric_item.name, user_item.id))
+        logger.info(f"Favorited metric {metric_item.name} for user (ID: {user_item.id})")
 
     # ------- delete from favorites
     # Response:
@@ -94,42 +94,42 @@ class Favorites(Endpoint):
 
     @api(version="3.15")
     def delete_favorite(self, user_item: UserItem, content_type: Resource, item: TableauItem) -> None:
-        url = "{0}/{1}/{2}/{3}".format(self.baseurl, user_item.id, content_type, item.id)
-        logger.info("Removing favorite {0}({1}) for user (ID: {2})".format(content_type, item.id, user_item.id))
+        url = f"{self.baseurl}/{user_item.id}/{content_type}/{item.id}"
+        logger.info(f"Removing favorite {content_type}({item.id}) for user (ID: {user_item.id})")
         self.delete_request(url)
 
     @api(version="2.0")
     def delete_favorite_workbook(self, user_item: UserItem, workbook_item: WorkbookItem) -> None:
-        url = "{0}/{1}/workbooks/{2}".format(self.baseurl, user_item.id, workbook_item.id)
-        logger.info("Removing favorite workbook {0} for user (ID: {1})".format(workbook_item.id, user_item.id))
+        url = f"{self.baseurl}/{user_item.id}/workbooks/{workbook_item.id}"
+        logger.info(f"Removing favorite workbook {workbook_item.id} for user (ID: {user_item.id})")
         self.delete_request(url)
 
     @api(version="2.0")
     def delete_favorite_view(self, user_item: UserItem, view_item: ViewItem) -> None:
-        url = "{0}/{1}/views/{2}".format(self.baseurl, user_item.id, view_item.id)
-        logger.info("Removing favorite view {0} for user (ID: {1})".format(view_item.id, user_item.id))
+        url = f"{self.baseurl}/{user_item.id}/views/{view_item.id}"
+        logger.info(f"Removing favorite view {view_item.id} for user (ID: {user_item.id})")
         self.delete_request(url)
 
     @api(version="2.3")
     def delete_favorite_datasource(self, user_item: UserItem, datasource_item: DatasourceItem) -> None:
-        url = "{0}/{1}/datasources/{2}".format(self.baseurl, user_item.id, datasource_item.id)
-        logger.info("Removing favorite {0} for user (ID: {1})".format(datasource_item.id, user_item.id))
+        url = f"{self.baseurl}/{user_item.id}/datasources/{datasource_item.id}"
+        logger.info(f"Removing favorite {datasource_item.id} for user (ID: {user_item.id})")
         self.delete_request(url)
 
     @api(version="3.1")
     def delete_favorite_project(self, user_item: UserItem, project_item: ProjectItem) -> None:
-        url = "{0}/{1}/projects/{2}".format(self.baseurl, user_item.id, project_item.id)
-        logger.info("Removing favorite project {0} for user (ID: {1})".format(project_item.id, user_item.id))
+        url = f"{self.baseurl}/{user_item.id}/projects/{project_item.id}"
+        logger.info(f"Removing favorite project {project_item.id} for user (ID: {user_item.id})")
         self.delete_request(url)
 
     @api(version="3.3")
     def delete_favorite_flow(self, user_item: UserItem, flow_item: FlowItem) -> None:
-        url = "{0}/{1}/flows/{2}".format(self.baseurl, user_item.id, flow_item.id)
-        logger.info("Removing favorite flow {0} for user (ID: {1})".format(flow_item.id, user_item.id))
+        url = f"{self.baseurl}/{user_item.id}/flows/{flow_item.id}"
+        logger.info(f"Removing favorite flow {flow_item.id} for user (ID: {user_item.id})")
         self.delete_request(url)
 
     @api(version="3.15")
     def delete_favorite_metric(self, user_item: UserItem, metric_item: MetricItem) -> None:
-        url = "{0}/{1}/metrics/{2}".format(self.baseurl, user_item.id, metric_item.id)
-        logger.info("Removing favorite metric {0} for user (ID: {1})".format(metric_item.id, user_item.id))
+        url = f"{self.baseurl}/{user_item.id}/metrics/{metric_item.id}"
+        logger.info(f"Removing favorite metric {metric_item.id} for user (ID: {user_item.id})")
         self.delete_request(url)

tableauserverclient/server/endpoint/fileuploads_endpoint.py

@@ -9,11 +9,11 @@ from tableauserverclient.server import RequestFactory
 
 class Fileuploads(Endpoint):
     def __init__(self, parent_srv):
-        super(Fileuploads, self).__init__(parent_srv)
+        super().__init__(parent_srv)
 
     @property
     def baseurl(self):
-        return "{0}/sites/{1}/fileUploads".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/fileUploads"
 
     @api(version="2.0")
     def initiate(self):
@@ -21,14 +21,14 @@ class Fileuploads(Endpoint):
         server_response = self.post_request(url, "")
         fileupload_item = FileuploadItem.from_response(server_response.content, self.parent_srv.namespace)
         upload_id = fileupload_item.upload_session_id
-        logger.info("Initiated file upload session (ID: {0})".format(upload_id))
+        logger.info(f"Initiated file upload session (ID: {upload_id})")
         return upload_id
 
     @api(version="2.0")
     def append(self, upload_id, data, content_type):
-        url = "{0}/{1}".format(self.baseurl, upload_id)
+        url = f"{self.baseurl}/{upload_id}"
         server_response = self.put_request(url, data, content_type)
-        logger.info("Uploading a chunk to session (ID: {0})".format(upload_id))
+        logger.info(f"Uploading a chunk to session (ID: {upload_id})")
         return FileuploadItem.from_response(server_response.content, self.parent_srv.namespace)
 
     def _read_chunks(self, file):
@@ -52,12 +52,10 @@ class Fileuploads(Endpoint):
     def upload(self, file):
         upload_id = self.initiate()
         for chunk in self._read_chunks(file):
-            logger.debug("{} processing chunk...".format(datetime.timestamp()))
+            logger.debug(f"{datetime.timestamp()} processing chunk...")
             request, content_type = RequestFactory.Fileupload.chunk_req(chunk)
-            logger.debug("{} created chunk request".format(datetime.timestamp()))
+            logger.debug(f"{datetime.timestamp()} created chunk request")
             fileupload_item = self.append(upload_id, request, content_type)
-            logger.info(
-                "\t{0} Published {1}MB".format(datetime.timestamp(), (fileupload_item.file_size / BYTES_PER_MB))
-            )
-        logger.info("File upload finished (ID: {0})".format(upload_id))
+            logger.info(f"\t{datetime.timestamp()} Published {(fileupload_item.file_size / BYTES_PER_MB)}MB")
+        logger.info(f"File upload finished (ID: {upload_id})")
         return upload_id

tableauserverclient/server/endpoint/flow_runs_endpoint.py

@@ -1,9 +1,9 @@
 import logging
-from typing import List, Optional, Tuple, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING, Union
 
 from tableauserverclient.server.endpoint.endpoint import QuerysetEndpoint, api
 from tableauserverclient.server.endpoint.exceptions import FlowRunFailedException, FlowRunCancelledException
-from tableauserverclient.models import FlowRunItem, PaginationItem
+from tableauserverclient.models import FlowRunItem
 from tableauserverclient.exponential_backoff import ExponentialBackoffTimer
 
 from tableauserverclient.helpers.logging import logger
@@ -16,22 +16,24 @@ if TYPE_CHECKING:
 
 class FlowRuns(QuerysetEndpoint[FlowRunItem]):
     def __init__(self, parent_srv: "Server") -> None:
-        super(FlowRuns, self).__init__(parent_srv)
+        super().__init__(parent_srv)
         return None
 
     @property
     def baseurl(self) -> str:
-        return "{0}/sites/{1}/flows/runs".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/flows/runs"
 
     # Get all flows
     @api(version="3.10")
-    def get(self, req_options: Optional["RequestOptions"] = None) -> Tuple[List[FlowRunItem], PaginationItem]:
+    # QuerysetEndpoint expects a PaginationItem to be returned, but FlowRuns
+    # does not return a PaginationItem. Suppressing the mypy error because the
+    # changes to the QuerySet class should permit this to function regardless.
+    def get(self, req_options: Optional["RequestOptions"] = None) -> list[FlowRunItem]:  # type: ignore[override]
         logger.info("Querying all flow runs on site")
         url = self.baseurl
         server_response = self.get_request(url, req_options)
-        pagination_item = PaginationItem.from_response(server_response.content, self.parent_srv.namespace)
         all_flow_run_items = FlowRunItem.from_response(server_response.content, self.parent_srv.namespace)
-        return all_flow_run_items, pagination_item
+        return all_flow_run_items
 
     # Get 1 flow by id
     @api(version="3.10")
@@ -39,21 +41,21 @@ class FlowRuns(QuerysetEndpoint[FlowRunItem]):
         if not flow_run_id:
             error = "Flow ID undefined."
             raise ValueError(error)
-        logger.info("Querying single flow (ID: {0})".format(flow_run_id))
-        url = "{0}/{1}".format(self.baseurl, flow_run_id)
+        logger.info(f"Querying single flow (ID: {flow_run_id})")
+        url = f"{self.baseurl}/{flow_run_id}"
         server_response = self.get_request(url)
         return FlowRunItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
     # Cancel 1 flow run by id
     @api(version="3.10")
-    def cancel(self, flow_run_id: str) -> None:
+    def cancel(self, flow_run_id: Union[str, FlowRunItem]) -> None:
         if not flow_run_id:
             error = "Flow ID undefined."
             raise ValueError(error)
         id_ = getattr(flow_run_id, "id", flow_run_id)
-        url = "{0}/{1}".format(self.baseurl, id_)
+        url = f"{self.baseurl}/{id_}"
         self.put_request(url)
-        logger.info("Deleted single flow (ID: {0})".format(id_))
+        logger.info(f"Deleted single flow (ID: {id_})")
 
     @api(version="3.10")
     def wait_for_job(self, flow_run_id: str, *, timeout: Optional[int] = None) -> FlowRunItem:
@@ -69,7 +71,7 @@ class FlowRuns(QuerysetEndpoint[FlowRunItem]):
             flow_run = self.get_by_id(flow_run_id)
             logger.debug(f"\tFlowRun {flow_run_id} progress={flow_run.progress}")
 
-        logger.info("FlowRun {} Completed: Status: {}".format(flow_run_id, flow_run.status))
+        logger.info(f"FlowRun {flow_run_id} Completed: Status: {flow_run.status}")
 
         if flow_run.status == "Success":
             return flow_run

tableauserverclient/server/endpoint/flow_task_endpoint.py

@@ -1,5 +1,5 @@
 import logging
-from typing import List, Optional, Tuple, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from tableauserverclient.server.endpoint.endpoint import Endpoint, api
 from tableauserverclient.server.endpoint.exceptions import MissingRequiredFieldError
@@ -15,7 +15,7 @@ if TYPE_CHECKING:
 class FlowTasks(Endpoint):
     @property
     def baseurl(self) -> str:
-        return "{0}/sites/{1}/tasks/flows".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/tasks/flows"
 
     @api(version="3.22")
     def create(self, flow_item: TaskItem) -> TaskItem: