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

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: