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

tableauserverclient/server/endpoint/subscriptions_endpoint.py

@@ -7,7 +7,7 @@ from tableauserverclient.models import SubscriptionItem, PaginationItem
 
 from tableauserverclient.helpers.logging import logger
 
-from typing import List, Optional, TYPE_CHECKING, Tuple
+from typing import Optional, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from ..request_options import RequestOptions
@@ -16,10 +16,10 @@ if TYPE_CHECKING:
 class Subscriptions(Endpoint):
     @property
     def baseurl(self) -> str:
-        return "{0}/sites/{1}/subscriptions".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/subscriptions"
 
     @api(version="2.3")
-    def get(self, req_options: Optional["RequestOptions"] = None) -> Tuple[List[SubscriptionItem], PaginationItem]:
+    def get(self, req_options: Optional["RequestOptions"] = None) -> tuple[list[SubscriptionItem], PaginationItem]:
         logger.info("Querying all subscriptions for the site")
         url = self.baseurl
         server_response = self.get_request(url, req_options)
@@ -33,8 +33,8 @@ class Subscriptions(Endpoint):
         if not subscription_id:
             error = "No Subscription ID provided"
             raise ValueError(error)
-        logger.info("Querying a single subscription by id ({})".format(subscription_id))
-        url = "{}/{}".format(self.baseurl, subscription_id)
+        logger.info(f"Querying a single subscription by id ({subscription_id})")
+        url = f"{self.baseurl}/{subscription_id}"
         server_response = self.get_request(url)
         return SubscriptionItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
@@ -43,7 +43,7 @@ class Subscriptions(Endpoint):
         if not subscription_item:
             error = "No Susbcription provided"
             raise ValueError(error)
-        logger.info("Creating a subscription ({})".format(subscription_item))
+        logger.info(f"Creating a subscription ({subscription_item})")
         url = self.baseurl
         create_req = RequestFactory.Subscription.create_req(subscription_item)
         server_response = self.post_request(url, create_req)
@@ -54,17 +54,17 @@ class Subscriptions(Endpoint):
         if not subscription_id:
             error = "Subscription ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}".format(self.baseurl, subscription_id)
+        url = f"{self.baseurl}/{subscription_id}"
         self.delete_request(url)
-        logger.info("Deleted subscription (ID: {0})".format(subscription_id))
+        logger.info(f"Deleted subscription (ID: {subscription_id})")
 
     @api(version="2.3")
     def update(self, subscription_item: SubscriptionItem) -> SubscriptionItem:
         if not subscription_item.id:
             error = "Subscription item missing ID. Subscription must be retrieved from server first."
             raise MissingRequiredFieldError(error)
-        url = "{0}/{1}".format(self.baseurl, subscription_item.id)
+        url = f"{self.baseurl}/{subscription_item.id}"
         update_req = RequestFactory.Subscription.update_req(subscription_item)
         server_response = self.put_request(url, update_req)
-        logger.info("Updated subscription item (ID: {0})".format(subscription_item.id))
+        logger.info(f"Updated subscription item (ID: {subscription_item.id})")
         return SubscriptionItem.from_response(server_response.content, self.parent_srv.namespace)[0]

tableauserverclient/server/endpoint/tables_endpoint.py

@@ -1,5 +1,6 @@
 import logging
-from typing import Iterable, Set, Union
+from typing import Union
+from collections.abc import Iterable
 
 from tableauserverclient.server.endpoint.dqw_endpoint import _DataQualityWarningEndpoint
 from tableauserverclient.server.endpoint.endpoint import api, Endpoint
@@ -15,14 +16,14 @@ from tableauserverclient.helpers.logging import logger
 
 class Tables(Endpoint, TaggingMixin[TableItem]):
     def __init__(self, parent_srv):
-        super(Tables, self).__init__(parent_srv)
+        super().__init__(parent_srv)
 
         self._permissions = _PermissionsEndpoint(parent_srv, lambda: self.baseurl)
         self._data_quality_warnings = _DataQualityWarningEndpoint(self.parent_srv, "table")
 
     @property
     def baseurl(self):
-        return "{0}/sites/{1}/tables".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/tables"
 
     @api(version="3.5")
     def get(self, req_options=None):
@@ -39,8 +40,8 @@ class Tables(Endpoint, TaggingMixin[TableItem]):
         if not table_id:
             error = "table ID undefined."
             raise ValueError(error)
-        logger.info("Querying single table (ID: {0})".format(table_id))
-        url = "{0}/{1}".format(self.baseurl, table_id)
+        logger.info(f"Querying single table (ID: {table_id})")
+        url = f"{self.baseurl}/{table_id}"
         server_response = self.get_request(url)
         return TableItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
@@ -49,9 +50,9 @@ class Tables(Endpoint, TaggingMixin[TableItem]):
         if not table_id:
             error = "Database ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}".format(self.baseurl, table_id)
+        url = f"{self.baseurl}/{table_id}"
         self.delete_request(url)
-        logger.info("Deleted single table (ID: {0})".format(table_id))
+        logger.info(f"Deleted single table (ID: {table_id})")
 
     @api(version="3.5")
     def update(self, table_item):
@@ -59,10 +60,10 @@ class Tables(Endpoint, TaggingMixin[TableItem]):
             error = "table item missing ID."
             raise MissingRequiredFieldError(error)
 
-        url = "{0}/{1}".format(self.baseurl, table_item.id)
+        url = f"{self.baseurl}/{table_item.id}"
         update_req = RequestFactory.Table.update_req(table_item)
         server_response = self.put_request(url, update_req)
-        logger.info("Updated table item (ID: {0})".format(table_item.id))
+        logger.info(f"Updated table item (ID: {table_item.id})")
         updated_table = TableItem.from_response(server_response.content, self.parent_srv.namespace)[0]
         return updated_table
 
@@ -80,10 +81,10 @@ class Tables(Endpoint, TaggingMixin[TableItem]):
             )
 
         table_item._set_columns(column_fetcher)
-        logger.info("Populated columns for table (ID: {0}".format(table_item.id))
+        logger.info(f"Populated columns for table (ID: {table_item.id}")
 
     def _get_columns_for_table(self, table_item, req_options=None):
-        url = "{0}/{1}/columns".format(self.baseurl, table_item.id)
+        url = f"{self.baseurl}/{table_item.id}/columns"
         server_response = self.get_request(url, req_options)
         columns = ColumnItem.from_response(server_response.content, self.parent_srv.namespace)
         pagination_item = PaginationItem.from_response(server_response.content, self.parent_srv.namespace)
@@ -91,12 +92,12 @@ class Tables(Endpoint, TaggingMixin[TableItem]):
 
     @api(version="3.5")
     def update_column(self, table_item, column_item):
-        url = "{0}/{1}/columns/{2}".format(self.baseurl, table_item.id, column_item.id)
+        url = f"{self.baseurl}/{table_item.id}/columns/{column_item.id}"
         update_req = RequestFactory.Column.update_req(column_item)
         server_response = self.put_request(url, update_req)
         column = ColumnItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
-        logger.info("Updated table item (ID: {0} & column item {1}".format(table_item.id, column_item.id))
+        logger.info(f"Updated table item (ID: {table_item.id} & column item {column_item.id}")
         return column
 
     @api(version="3.5")
@@ -128,7 +129,7 @@ class Tables(Endpoint, TaggingMixin[TableItem]):
         self._data_quality_warnings.clear(item)
 
     @api(version="3.9")
-    def add_tags(self, item: Union[TableItem, str], tags: Union[Iterable[str], str]) -> Set[str]:
+    def add_tags(self, item: Union[TableItem, str], tags: Union[Iterable[str], str]) -> set[str]:
         return super().add_tags(item, tags)
 
     @api(version="3.9")

tableauserverclient/server/endpoint/tasks_endpoint.py

@@ -1,5 +1,5 @@
 import logging
-from typing import List, Optional, Tuple, TYPE_CHECKING
+from typing import Optional, 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 Tasks(Endpoint):
     @property
     def baseurl(self) -> str:
-        return "{0}/sites/{1}/tasks".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/tasks"
 
     def __normalize_task_type(self, task_type: str) -> str:
         """
@@ -23,20 +23,38 @@ class Tasks(Endpoint):
         It is different than the tag "extractRefresh" used in the request body.
         """
         if task_type == TaskItem.Type.ExtractRefresh:
-            return "{}es".format(task_type)
+            return f"{task_type}es"
         else:
             return task_type
 
     @api(version="2.6")
     def get(
         self, req_options: Optional["RequestOptions"] = None, task_type: str = TaskItem.Type.ExtractRefresh
-    ) -> Tuple[List[TaskItem], PaginationItem]:
+    ) -> tuple[list[TaskItem], PaginationItem]:
+        """
+        Returns information about tasks on the specified site.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_jobs_tasks_and_schedules.htm#list_extract_refresh_tasks
+
+        Parameters
+        ----------
+        req_options : RequestOptions, optional
+            Options for the request, such as filtering, sorting, and pagination.
+
+        task_type : str, optional
+            The type of task to query. See TaskItem.Type for possible values.
+
+        Returns
+        -------
+        tuple[list[TaskItem], PaginationItem]
+
+        """
         if task_type == TaskItem.Type.DataAcceleration:
             self.parent_srv.assert_at_least_version("3.8", "Data Acceleration Tasks")
 
         logger.info("Querying all %s tasks for the site", task_type)
 
-        url = "{0}/{1}".format(self.baseurl, self.__normalize_task_type(task_type))
+        url = f"{self.baseurl}/{self.__normalize_task_type(task_type)}"
         server_response = self.get_request(url, req_options)
 
         pagination_item = PaginationItem.from_response(server_response.content, self.parent_srv.namespace)
@@ -45,6 +63,20 @@ class Tasks(Endpoint):
 
     @api(version="2.6")
     def get_by_id(self, task_id: str) -> TaskItem:
+        """
+        Returns information about the specified task.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_jobs_tasks_and_schedules.htm#get_extract_refresh_task
+
+        Parameters
+        ----------
+        task_id : str
+            The ID of the task to query.
+
+        Returns
+        -------
+        TaskItem
+        """
         if not task_id:
             error = "No Task ID provided"
             raise ValueError(error)
@@ -59,22 +91,51 @@ class Tasks(Endpoint):
 
     @api(version="3.19")
     def create(self, extract_item: TaskItem) -> TaskItem:
+        """
+        Creates a custom schedule for an extract refresh on Tableau Cloud. For
+        Tableau Server, use the Schedules endpoint to create a schedule.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref.htm#create_cloud_extract_refresh_task
+
+        Parameters
+        ----------
+        extract_item : TaskItem
+            The extract refresh task to create.
+
+        Returns
+        -------
+        TaskItem
+        """
         if not extract_item:
             error = "No extract refresh provided"
             raise ValueError(error)
         logger.info("Creating an extract refresh %s", extract_item)
-        url = "{0}/{1}".format(self.baseurl, self.__normalize_task_type(TaskItem.Type.ExtractRefresh))
+        url = f"{self.baseurl}/{self.__normalize_task_type(TaskItem.Type.ExtractRefresh)}"
         create_req = RequestFactory.Task.create_extract_req(extract_item)
         server_response = self.post_request(url, create_req)
         return server_response.content
 
     @api(version="2.6")
     def run(self, task_item: TaskItem) -> bytes:
+        """
+        Runs the specified extract refresh task.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_jobs_tasks_and_schedules.htm#run_extract_refresh_task
+
+        Parameters
+        ----------
+        task_item : TaskItem
+            The task to run.
+
+        Returns
+        -------
+        bytes
+        """
         if not task_item.id:
             error = "Task item missing ID."
             raise MissingRequiredFieldError(error)
 
-        url = "{0}/{1}/{2}/runNow".format(
+        url = "{}/{}/{}/runNow".format(
             self.baseurl,
             self.__normalize_task_type(TaskItem.Type.ExtractRefresh),
             task_item.id,
@@ -86,12 +147,29 @@ class Tasks(Endpoint):
     # Delete 1 task by id
     @api(version="3.6")
     def delete(self, task_id: str, task_type: str = TaskItem.Type.ExtractRefresh) -> None:
+        """
+        Deletes the specified extract refresh task on Tableau Server or Tableau Cloud.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref.htm#delete_extract_refresh_task
+
+        Parameters
+        ----------
+        task_id : str
+            The ID of the task to delete.
+
+        task_type : str, default TaskItem.Type.ExtractRefresh
+            The type of task to query. See TaskItem.Type for possible values.
+
+        Returns
+        -------
+        None
+        """
         if task_type == TaskItem.Type.DataAcceleration:
             self.parent_srv.assert_at_least_version("3.8", "Data Acceleration Tasks")
 
         if not task_id:
             error = "No Task ID provided"
             raise ValueError(error)
-        url = "{0}/{1}/{2}".format(self.baseurl, self.__normalize_task_type(task_type), task_id)
+        url = f"{self.baseurl}/{self.__normalize_task_type(task_type)}/{task_id}"
         self.delete_request(url)
         logger.info("Deleted single task (ID: %s)", task_id)