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

tableauserverclient/server/endpoint/sites_endpoint.py

@@ -8,20 +8,49 @@ from tableauserverclient.models import SiteItem, PaginationItem
 
 from tableauserverclient.helpers.logging import logger
 
-from typing import TYPE_CHECKING, List, Optional, Tuple
+from typing import TYPE_CHECKING, Optional
 
 if TYPE_CHECKING:
     from ..request_options import RequestOptions
 
 
 class Sites(Endpoint):
+    """
+    Using the site methods of the Tableau Server REST API you can:
+
+    List sites on a server or get details of a specific site
+    Create, update, or delete a site
+    List views in a site
+    Encrypt, decrypt, or reencrypt extracts on a site
+
+    """
+
     @property
     def baseurl(self) -> str:
-        return "{0}/sites".format(self.parent_srv.baseurl)
+        return f"{self.parent_srv.baseurl}/sites"
 
     # Gets all sites
     @api(version="2.0")
-    def get(self, req_options: Optional["RequestOptions"] = None) -> Tuple[List[SiteItem], PaginationItem]:
+    def get(self, req_options: Optional["RequestOptions"] = None) -> tuple[list[SiteItem], PaginationItem]:
+        """
+        Query all sites on the server. This method requires server admin
+        permissions. This endpoint is paginated, meaning that the server will
+        only return a subset of the data at a time. The response will contain
+        information about the total number of sites and the number of sites
+        returned in the current response. Use the PaginationItem object to
+        request more data.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref.htm#query_sites
+
+        Parameters
+        ----------
+        req_options : RequestOptions, optional
+            Filtering options for the request.
+
+        Returns
+        -------
+        tuple[list[SiteItem], PaginationItem]
+        """
         logger.info("Querying all sites on site")
         logger.info("Requires Server Admin permissions")
         url = self.baseurl
@@ -33,6 +62,33 @@ class Sites(Endpoint):
     # Gets 1 site by id
     @api(version="2.0")
     def get_by_id(self, site_id: str) -> SiteItem:
+        """
+        Query a single site on the server. You can only retrieve the site that
+        you are currently authenticated for.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref.htm#query_site
+
+        Parameters
+        ----------
+        site_id : str
+            The site ID.
+
+        Returns
+        -------
+        SiteItem
+
+        Raises
+        ------
+        ValueError
+            If the site ID is not defined.
+
+        ValueError
+            If the site ID does not match the site for which you are currently authenticated.
+
+        Examples
+        --------
+        >>> site = server.sites.get_by_id('1a2b3c4d-5e6f-7g8h-9i0j-1k2l3m4n5o6p')
+        """
         if not site_id:
             error = "Site ID undefined."
             raise ValueError(error)
@@ -40,20 +96,45 @@ class Sites(Endpoint):
             error = "You can only retrieve the site for which you are currently authenticated."
             raise ValueError(error)
 
-        logger.info("Querying single site (ID: {0})".format(site_id))
-        url = "{0}/{1}".format(self.baseurl, site_id)
+        logger.info(f"Querying single site (ID: {site_id})")
+        url = f"{self.baseurl}/{site_id}"
         server_response = self.get_request(url)
         return SiteItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
     # Gets 1 site by name
     @api(version="2.0")
     def get_by_name(self, site_name: str) -> SiteItem:
+        """
+        Query a single site on the server. You can only retrieve the site that
+        you are currently authenticated for.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref.htm#query_site
+
+        Parameters
+        ----------
+        site_name : str
+            The site name.
+
+        Returns
+        -------
+        SiteItem
+
+        Raises
+        ------
+        ValueError
+            If the site name is not defined.
+
+        Examples
+        --------
+        >>> site = server.sites.get_by_name('Tableau')
+
+        """
         if not site_name:
             error = "Site Name undefined."
             raise ValueError(error)
         print("Note: You can only work with the site for which you are currently authenticated")
-        logger.info("Querying single site (Name: {0})".format(site_name))
-        url = "{0}/{1}?key=name".format(self.baseurl, site_name)
+        logger.info(f"Querying single site (Name: {site_name})")
+        url = f"{self.baseurl}/{site_name}?key=name"
         print(self.baseurl, url)
         server_response = self.get_request(url)
         return SiteItem.from_response(server_response.content, self.parent_srv.namespace)[0]
@@ -61,6 +142,31 @@ class Sites(Endpoint):
     # Gets 1 site by content url
     @api(version="2.0")
     def get_by_content_url(self, content_url: str) -> SiteItem:
+        """
+        Query a single site on the server. You can only retrieve the site that
+        you are currently authenticated for.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref.htm#query_site
+
+        Parameters
+        ----------
+        content_url : str
+            The content URL.
+
+        Returns
+        -------
+        SiteItem
+
+        Raises
+        ------
+        ValueError
+            If the site name is not defined.
+
+        Examples
+        --------
+        >>> site = server.sites.get_by_name('Tableau')
+
+        """
         if content_url is None:
             error = "Content URL undefined."
             raise ValueError(error)
@@ -68,15 +174,51 @@ class Sites(Endpoint):
             error = "You can only work with the site you are currently authenticated for"
             raise ValueError(error)
 
-        logger.info("Querying single site (Content URL: {0})".format(content_url))
+        logger.info(f"Querying single site (Content URL: {content_url})")
         logger.debug("Querying other sites requires Server Admin permissions")
-        url = "{0}/{1}?key=contentUrl".format(self.baseurl, content_url)
+        url = f"{self.baseurl}/{content_url}?key=contentUrl"
         server_response = self.get_request(url)
         return SiteItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
     # Update site
     @api(version="2.0")
     def update(self, site_item: SiteItem) -> SiteItem:
+        """
+        Modifies the settings for site.
+
+        The site item object must include the site ID and overrides all other settings.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref.htm#update_site
+
+        Parameters
+        ----------
+        site_item : SiteItem
+            The site item that you want to update. The settings specified in the
+            site item override the current site settings.
+
+        Returns
+        -------
+        SiteItem
+            The site item object that was updated.
+
+        Raises
+        ------
+        MissingRequiredFieldError
+            If the site item is missing an ID.
+
+        ValueError
+            If the site ID does not match the site for which you are currently authenticated.
+
+        ValueError
+            If the site admin mode is set to ContentOnly and a user quota is also set.
+
+        Examples
+        --------
+        >>> ...
+        >>> site_item.name = 'New Name'
+        >>> updated_site = server.sites.update(site_item)
+
+        """
         if not site_item.id:
             error = "Site item missing ID."
             raise MissingRequiredFieldError(error)
@@ -90,30 +232,94 @@ class Sites(Endpoint):
                 error = "You cannot set admin_mode to ContentOnly and also set a user quota"
                 raise ValueError(error)
 
-        url = "{0}/{1}".format(self.baseurl, site_item.id)
+        url = f"{self.baseurl}/{site_item.id}"
         update_req = RequestFactory.Site.update_req(site_item, self.parent_srv)
         server_response = self.put_request(url, update_req)
-        logger.info("Updated site item (ID: {0})".format(site_item.id))
+        logger.info(f"Updated site item (ID: {site_item.id})")
         update_site = copy.copy(site_item)
         return update_site._parse_common_tags(server_response.content, self.parent_srv.namespace)
 
     # Delete 1 site object
     @api(version="2.0")
     def delete(self, site_id: str) -> None:
+        """
+        Deletes the specified site from the server. You can only delete the site
+        if you are a Server Admin.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref.htm#delete_site
+
+        Parameters
+        ----------
+        site_id : str
+            The site ID.
+
+        Raises
+        ------
+        ValueError
+            If the site ID is not defined.
+
+        ValueError
+            If the site ID does not match the site for which you are currently authenticated.
+
+        Examples
+        --------
+        >>> server.sites.delete('1a2b3c4d-5e6f-7g8h-9i0j-1k2l3m4n5o6p')
+        """
         if not site_id:
             error = "Site ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}".format(self.baseurl, site_id)
+        url = f"{self.baseurl}/{site_id}"
         if not site_id == self.parent_srv.site_id:
             error = "You can only delete the site you are currently authenticated for"
             raise ValueError(error)
         self.delete_request(url)
         self.parent_srv._clear_auth()
-        logger.info("Deleted single site (ID: {0}) and signed out".format(site_id))
+        logger.info(f"Deleted single site (ID: {site_id}) and signed out")
 
     # Create new site
     @api(version="2.0")
     def create(self, site_item: SiteItem) -> SiteItem:
+        """
+        Creates a new site on the server for the specified site item object.
+
+        Tableau Server only.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref.htm#create_site
+
+        Parameters
+        ----------
+        site_item : SiteItem
+            The settings for the site that you want to create. You need to
+            create an instance of SiteItem and pass it to the create method.
+
+        Returns
+        -------
+        SiteItem
+            The site item object that was created.
+
+        Raises
+        ------
+        ValueError
+            If the site admin mode is set to ContentOnly and a user quota is also set.
+
+        Examples
+        --------
+        >>> import tableauserverclient as TSC
+
+        >>> # create an instance of server
+        >>> server = TSC.Server('https://MY-SERVER')
+
+        >>> # create shortcut for admin mode
+        >>> content_users=TSC.SiteItem.AdminMode.ContentAndUsers
+
+        >>> # create a new SiteItem
+        >>> new_site = TSC.SiteItem(name='Tableau', content_url='tableau', admin_mode=content_users, user_quota=15, storage_quota=1000, disable_subscriptions=True)
+
+        >>> # call the sites create method with the SiteItem
+        >>> new_site = server.sites.create(new_site)
+
+
+        """
         if site_item.admin_mode:
             if site_item.admin_mode == SiteItem.AdminMode.ContentOnly and site_item.user_quota:
                 error = "You cannot set admin_mode to ContentOnly and also set a user quota"
@@ -123,33 +329,92 @@ class Sites(Endpoint):
         create_req = RequestFactory.Site.create_req(site_item, self.parent_srv)
         server_response = self.post_request(url, create_req)
         new_site = SiteItem.from_response(server_response.content, self.parent_srv.namespace)[0]
-        logger.info("Created new site (ID: {0})".format(new_site.id))
+        logger.info(f"Created new site (ID: {new_site.id})")
         return new_site
 
     @api(version="3.5")
     def encrypt_extracts(self, site_id: str) -> None:
+        """
+        Encrypts all extracts on the site.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_extract_and_encryption.htm#encrypt_extracts
+
+        Parameters
+        ----------
+        site_id : str
+            The site ID.
+
+        Raises
+        ------
+        ValueError
+            If the site ID is not defined.
+
+        Examples
+        --------
+        >>> server.sites.encrypt_extracts('1a2b3c4d-5e6f-7g8h-9i0j-1k2l3m4n5o6p')
+        """
         if not site_id:
             error = "Site ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}/encrypt-extracts".format(self.baseurl, site_id)
+        url = f"{self.baseurl}/{site_id}/encrypt-extracts"
         empty_req = RequestFactory.Empty.empty_req()
         self.post_request(url, empty_req)
 
     @api(version="3.5")
     def decrypt_extracts(self, site_id: str) -> None:
+        """
+        Decrypts all extracts on the site.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_extract_and_encryption.htm#decrypt_extracts
+
+        Parameters
+        ----------
+        site_id : str
+            The site ID.
+
+        Raises
+        ------
+        ValueError
+            If the site ID is not defined.
+
+        Examples
+        --------
+        >>> server.sites.decrypt_extracts('1a2b3c4d-5e6f-7g8h-9i0j-1k2l3m4n5o6p')
+        """
         if not site_id:
             error = "Site ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}/decrypt-extracts".format(self.baseurl, site_id)
+        url = f"{self.baseurl}/{site_id}/decrypt-extracts"
         empty_req = RequestFactory.Empty.empty_req()
         self.post_request(url, empty_req)
 
     @api(version="3.5")
     def re_encrypt_extracts(self, site_id: str) -> None:
+        """
+        Reencrypt all extracts on a site with new encryption keys. If no site is
+        specified, extracts on the default site will be reencrypted.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_extract_and_encryption.htm#reencrypt_extracts
+
+        Parameters
+        ----------
+        site_id : str
+            The site ID.
+
+        Raises
+        ------
+        ValueError
+            If the site ID is not defined.
+
+        Examples
+        --------
+        >>> server.sites.re_encrypt_extracts('1a2b3c4d-5e6f-7g8h-9i0j-1k2l3m4n5o6p')
+
+        """
         if not site_id:
             error = "Site ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}/reencrypt-extracts".format(self.baseurl, site_id)
+        url = f"{self.baseurl}/{site_id}/reencrypt-extracts"
 
         empty_req = RequestFactory.Empty.empty_req()
         self.post_request(url, empty_req)

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,26 +1,29 @@
 import logging
-
-from .dqw_endpoint import _DataQualityWarningEndpoint
-from .endpoint import api, Endpoint
-from .exceptions import MissingRequiredFieldError
-from .permissions_endpoint import _PermissionsEndpoint
+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
+from tableauserverclient.server.endpoint.exceptions import MissingRequiredFieldError
+from tableauserverclient.server.endpoint.permissions_endpoint import _PermissionsEndpoint
+from tableauserverclient.server.endpoint.resource_tagger import TaggingMixin
 from tableauserverclient.server import RequestFactory
 from tableauserverclient.models import TableItem, ColumnItem, PaginationItem
-from ..pager import Pager
+from tableauserverclient.server.pager import Pager
 
 from tableauserverclient.helpers.logging import logger
 
 
-class Tables(Endpoint):
+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):
@@ -37,8 +40,8 @@ class Tables(Endpoint):
         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]
 
@@ -47,9 +50,9 @@ class Tables(Endpoint):
         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):
@@ -57,10 +60,10 @@ class Tables(Endpoint):
             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
 
@@ -78,10 +81,10 @@ class Tables(Endpoint):
             )
 
         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)
@@ -89,12 +92,12 @@ class Tables(Endpoint):
 
     @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")
@@ -124,3 +127,14 @@ class Tables(Endpoint):
     @api(version="3.5")
     def delete_dqw(self, item):
         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]:
+        return super().add_tags(item, tags)
+
+    @api(version="3.9")
+    def delete_tags(self, item: Union[TableItem, str], tags: Union[Iterable[str], str]) -> None:
+        return super().delete_tags(item, tags)
+
+    def update_tags(self, item: TableItem) -> None:  # type: ignore
+        raise NotImplementedError("Update tags is not implemented for TableItem")

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,20 @@ 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]:
         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)
@@ -63,7 +63,7 @@ class Tasks(Endpoint):
             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
@@ -74,7 +74,7 @@ class Tasks(Endpoint):
             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,
@@ -92,6 +92,6 @@ class Tasks(Endpoint):
         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)