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

tableauserverclient/server/endpoint/groups_endpoint.py

@@ -8,7 +8,8 @@ from tableauserverclient.server.pager import Pager
 
 from tableauserverclient.helpers.logging import logger
 
-from typing import Iterable, List, Optional, TYPE_CHECKING, Tuple, Union
+from typing import Literal, Optional, TYPE_CHECKING, Union, overload
+from collections.abc import Iterable
 
 from tableauserverclient.server.query import QuerySet
 
@@ -17,13 +18,56 @@ if TYPE_CHECKING:
 
 
 class Groups(QuerysetEndpoint[GroupItem]):
+    """
+    Groups endpoint for creating, reading, updating, and deleting groups on
+    Tableau Server.
+    """
+
     @property
     def baseurl(self) -> str:
-        return "{0}/sites/{1}/groups".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/groups"
 
     @api(version="2.0")
-    def get(self, req_options: Optional["RequestOptions"] = None) -> Tuple[List[GroupItem], PaginationItem]:
-        """Gets all groups"""
+    def get(self, req_options: Optional["RequestOptions"] = None) -> tuple[list[GroupItem], PaginationItem]:
+        """
+        Returns information about the groups on the site.
+
+        To get information about the users in a group, you must first populate
+        the GroupItem with user information using the groups.populate_users
+        method.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_users_and_groups.htm#query_groups
+
+        Parameters
+        ----------
+        req_options : Optional[RequestOptions]
+            (Optional) You can pass the method a request object that contains
+            additional parameters to filter the request. For example, if you
+            were searching for a specific group, you could specify the name of
+            the group or the group id.
+
+        Returns
+        -------
+        tuple[list[GroupItem], PaginationItem]
+
+        Examples
+        --------
+        >>> # import tableauserverclient as TSC
+        >>> # tableau_auth = TSC.TableauAuth('USERNAME', 'PASSWORD')
+        >>> # server = TSC.Server('https://SERVERURL')
+
+        >>> with server.auth.sign_in(tableau_auth):
+
+        >>>     # get the groups on the server
+        >>>     all_groups, pagination_item = server.groups.get()
+
+        >>>     # print the names of the first 100 groups
+        >>>     for group in all_groups :
+        >>>         print(group.name, group.id)
+
+
+
+        """
         logger.info("Querying all groups on site")
         url = self.baseurl
         server_response = self.get_request(url, req_options)
@@ -33,7 +77,42 @@ class Groups(QuerysetEndpoint[GroupItem]):
 
     @api(version="2.0")
     def populate_users(self, group_item: GroupItem, req_options: Optional["RequestOptions"] = None) -> None:
-        """Gets all users in a given group"""
+        """
+        Populates the group_item with the list of users.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_users_and_groups.htm#get_users_in_group
+
+        Parameters
+        ----------
+        group_item : GroupItem
+            The group item to populate with user information.
+
+        req_options : Optional[RequestOptions]
+            (Optional) You can pass the method a request object that contains
+            page size and page number.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        MissingRequiredFieldError
+            If the group item does not have an ID, the method raises an error.
+
+        Examples
+        --------
+        >>> # Get the group item from the server
+        >>> groups, pagination_item = server.groups.get()
+        >>> group = groups[1]
+
+        >>> # Populate the group with user information
+        >>> server.groups.populate_users(group)
+        >>> for user in group.users:
+        >>>     print(user.name)
+
+
+        """
         if not group_item.id:
             error = "Group item missing ID. Group must be retrieved from server first."
             raise MissingRequiredFieldError(error)
@@ -50,27 +129,86 @@ class Groups(QuerysetEndpoint[GroupItem]):
 
     def _get_users_for_group(
         self, group_item: GroupItem, req_options: Optional["RequestOptions"] = None
-    ) -> Tuple[List[UserItem], PaginationItem]:
-        url = "{0}/{1}/users".format(self.baseurl, group_item.id)
+    ) -> tuple[list[UserItem], PaginationItem]:
+        url = f"{self.baseurl}/{group_item.id}/users"
         server_response = self.get_request(url, req_options)
         user_item = UserItem.from_response(server_response.content, self.parent_srv.namespace)
         pagination_item = PaginationItem.from_response(server_response.content, self.parent_srv.namespace)
-        logger.info("Populated users for group (ID: {0})".format(group_item.id))
+        logger.info(f"Populated users for group (ID: {group_item.id})")
         return user_item, pagination_item
 
     @api(version="2.0")
     def delete(self, group_id: str) -> None:
-        """Deletes 1 group by id"""
+        """
+        Deletes the group on the site.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_users_and_groups.htm#delete_group
+
+        Parameters
+        ----------
+        group_id: str
+            The id for the group you want to remove from the server
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        ValueError
+            If the group_id is not provided, the method raises an error.
+
+        Examples
+        --------
+        >>> groups, pagination_item = server.groups.get()
+        >>> group = groups[1]
+        >>> server.groups.delete(group.id)
+
+        """
         if not group_id:
             error = "Group ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}".format(self.baseurl, group_id)
+        url = f"{self.baseurl}/{group_id}"
         self.delete_request(url)
-        logger.info("Deleted single group (ID: {0})".format(group_id))
+        logger.info(f"Deleted single group (ID: {group_id})")
+
+    @overload
+    def update(self, group_item: GroupItem, as_job: Literal[False]) -> GroupItem: ...
+
+    @overload
+    def update(self, group_item: GroupItem, as_job: Literal[True]) -> JobItem: ...
 
     @api(version="2.0")
-    def update(self, group_item: GroupItem, as_job: bool = False) -> Union[GroupItem, JobItem]:
-        url = "{0}/{1}".format(self.baseurl, group_item.id)
+    def update(self, group_item, as_job=False):
+        """
+        Updates a group on the site.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_users_and_groups.htm#update_group
+
+        Parameters
+        ----------
+        group_item : GroupItem
+            The group item to update.
+
+        as_job : bool
+            (Optional) If this value is set to True, the update operation will
+            be asynchronous and return a JobItem. This is only supported for
+            Active Directory groups. By default, this value is set to False.
+
+        Returns
+        -------
+        Union[GroupItem, JobItem]
+
+        Raises
+        ------
+        MissingRequiredFieldError
+            If the group_item does not have an ID, the method raises an error.
+
+        ValueError
+            If the group_item is a local group and as_job is set to True, the
+            method raises an error.
+        """
+        url = f"{self.baseurl}/{group_item.id}"
 
         if not group_item.id:
             error = "Group item missing ID."
@@ -83,7 +221,7 @@ class Groups(QuerysetEndpoint[GroupItem]):
 
         update_req = RequestFactory.Group.update_req(group_item)
         server_response = self.put_request(url, update_req)
-        logger.info("Updated group item (ID: {0})".format(group_item.id))
+        logger.info(f"Updated group item (ID: {group_item.id})")
         if as_job:
             return JobItem.from_response(server_response.content, self.parent_srv.namespace)[0]
         else:
@@ -91,15 +229,71 @@ class Groups(QuerysetEndpoint[GroupItem]):
 
     @api(version="2.0")
     def create(self, group_item: GroupItem) -> GroupItem:
-        """Create a 'local' Tableau group"""
+        """
+        Create a 'local' Tableau group
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_users_and_groups.htm#create_group
+
+        Parameters
+        ----------
+        group_item : GroupItem
+            The group item to create. The group_item specifies the group to add.
+            You first create a new instance of a GroupItem and pass that to this
+            method.
+
+        Returns
+        -------
+        GroupItem
+
+        Examples
+        --------
+        >>> new_group = TSC.GroupItem('new_group')
+        >>> new_group.minimum_site_role = TSC.UserItem.Role.ExplorerCanPublish
+        >>> new_group = server.groups.create(new_group)
+
+        """
         url = self.baseurl
         create_req = RequestFactory.Group.create_local_req(group_item)
         server_response = self.post_request(url, create_req)
         return GroupItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
+    @overload
+    def create_AD_group(self, group_item: GroupItem, asJob: Literal[False]) -> GroupItem: ...
+
+    @overload
+    def create_AD_group(self, group_item: GroupItem, asJob: Literal[True]) -> JobItem: ...
+
     @api(version="2.0")
-    def create_AD_group(self, group_item: GroupItem, asJob: bool = False) -> Union[GroupItem, JobItem]:
-        """Create a group based on Active Directory"""
+    def create_AD_group(self, group_item, asJob=False):
+        """
+        Create a group based on Active Directory.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_users_and_groups.htm#create_group
+
+        Parameters
+        ----------
+        group_item : GroupItem
+            The group item to create. The group_item specifies the group to add.
+            You first create a new instance of a GroupItem and pass that to this
+            method.
+
+        asJob : bool
+            (Optional) If this value is set to True, the create operation will
+            be asynchronous and return a JobItem. This is only supported for
+            Active Directory groups. By default, this value is set to False.
+
+        Returns
+        -------
+        Union[GroupItem, JobItem]
+
+        Examples
+        --------
+        >>> new_ad_group = TSC.GroupItem('new_ad_group')
+        >>> new_ad_group.domain_name = 'example.com'
+        >>> new_ad_group.minimum_site_role = TSC.UserItem.Role.ExplorerCanPublish
+        >>> new_ad_group.license_mode = TSC.GroupItem.LicenseMode.onSync
+        >>> new_ad_group = server.groups.create_AD_group(new_ad_group)
+        """
         asJobparameter = "?asJob=true" if asJob else ""
         url = self.baseurl + asJobparameter
         create_req = RequestFactory.Group.create_ad_req(group_item)
@@ -111,20 +305,80 @@ class Groups(QuerysetEndpoint[GroupItem]):
 
     @api(version="2.0")
     def remove_user(self, group_item: GroupItem, user_id: str) -> None:
-        """Removes 1 user from 1 group"""
+        """
+        Removes 1 user from 1 group
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_users_and_groups.htm#remove_user_to_group
+
+        Parameters
+        ----------
+        group_item : GroupItem
+            The group item from which to remove the user.
+
+        user_id : str
+            The ID of the user to remove from the group.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        MissingRequiredFieldError
+            If the group_item does not have an ID, the method raises an error.
+
+        ValueError
+            If the user_id is not provided, the method raises an error.
+
+        Examples
+        --------
+        >>> group = server.groups.get_by_id('1a2b3c4d-5e6f-7g8h-9i0j-1k2l3m4n5o6p')
+        >>> server.groups.populate_users(group)
+        >>> server.groups.remove_user(group, group.users[0].id)
+        """
         if not group_item.id:
             error = "Group item missing ID."
             raise MissingRequiredFieldError(error)
         if not user_id:
             error = "User ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}/users/{2}".format(self.baseurl, group_item.id, user_id)
+        url = f"{self.baseurl}/{group_item.id}/users/{user_id}"
         self.delete_request(url)
-        logger.info("Removed user (id: {0}) from group (ID: {1})".format(user_id, group_item.id))
+        logger.info(f"Removed user (id: {user_id}) from group (ID: {group_item.id})")
 
     @api(version="3.21")
     def remove_users(self, group_item: GroupItem, users: Iterable[Union[str, UserItem]]) -> None:
-        """Removes multiple users from 1 group"""
+        """
+        Removes multiple users from 1 group. This makes a single API call to
+        remove the provided users.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_users_and_groups.htm#remove_users_to_group
+
+        Parameters
+        ----------
+        group_item : GroupItem
+            The group item from which to remove the user.
+
+        users : Iterable[Union[str, UserItem]]
+            The IDs or UserItems with IDs of the users to remove from the group.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        ValueError
+            If the group_item is not a GroupItem or str, the method raises an error.
+
+        Examples
+        --------
+        >>> group = server.groups.get_by_id('1a2b3c4d-5e6f-7g8h-9i0j-1k2l3m4n5o6p')
+        >>> server.groups.populate_users(group)
+        >>> users = [u for u in group.users if u.domain_name == 'example.com']
+        >>> server.groups.remove_users(group, users)
+
+        """
         group_id = group_item.id if hasattr(group_item, "id") else group_item
         if not isinstance(group_id, str):
             raise ValueError(f"Invalid group provided: {group_item}")
@@ -132,27 +386,88 @@ class Groups(QuerysetEndpoint[GroupItem]):
         url = f"{self.baseurl}/{group_id}/users/remove"
         add_req = RequestFactory.Group.remove_users_req(users)
         _ = self.put_request(url, add_req)
-        logger.info("Removed users to group (ID: {0})".format(group_item.id))
+        logger.info(f"Removed users to group (ID: {group_item.id})")
         return None
 
     @api(version="2.0")
     def add_user(self, group_item: GroupItem, user_id: str) -> UserItem:
-        """Adds 1 user to 1 group"""
+        """
+        Adds 1 user to 1 group
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_users_and_groups.htm#add_user_to_group
+
+        Parameters
+        ----------
+        group_item : GroupItem
+            The group item to which to add the user.
+
+        user_id : str
+            The ID of the user to add to the group.
+
+        Returns
+        -------
+        UserItem
+            UserItem for the user that was added to the group.
+
+        Raises
+        ------
+        MissingRequiredFieldError
+            If the group_item does not have an ID, the method raises an error.
+
+        ValueError
+            If the user_id is not provided, the method raises an error.
+
+        Examples
+        --------
+        >>> group = server.groups.get_by_id('1a2b3c4d-5e6f-7g8h-9i0j-1k2l3m4n5o6p')
+        >>> server.groups.add_user(group, '1a2b3c4d-5e6f-7g8h-9i0j-1k2l3m4n5o6p')
+        """
         if not group_item.id:
             error = "Group item missing ID."
             raise MissingRequiredFieldError(error)
         if not user_id:
             error = "User ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}/users".format(self.baseurl, group_item.id)
+        url = f"{self.baseurl}/{group_item.id}/users"
         add_req = RequestFactory.Group.add_user_req(user_id)
         server_response = self.post_request(url, add_req)
         user = UserItem.from_response(server_response.content, self.parent_srv.namespace).pop()
-        logger.info("Added user (id: {0}) to group (ID: {1})".format(user_id, group_item.id))
+        logger.info(f"Added user (id: {user_id}) to group (ID: {group_item.id})")
         return user
 
     @api(version="3.21")
-    def add_users(self, group_item: GroupItem, users: Iterable[Union[str, UserItem]]) -> List[UserItem]:
+    def add_users(self, group_item: GroupItem, users: Iterable[Union[str, UserItem]]) -> list[UserItem]:
+        """
+        Adds 1 or more user to 1 group
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_users_and_groups.htm#add_user_to_group
+
+        Parameters
+        ----------
+        group_item : GroupItem
+            The group item to which to add the user.
+
+        user_id : Iterable[Union[str, UserItem]]
+            User IDs or UserItems with IDs to add to the group.
+
+        Returns
+        -------
+        list[UserItem]
+            UserItem for the user that was added to the group.
+
+        Raises
+        ------
+        MissingRequiredFieldError
+            If the group_item does not have an ID, the method raises an error.
+
+        ValueError
+            If the user_id is not provided, the method raises an error.
+
+        Examples
+        --------
+        >>> group = server.groups.get_by_id('1a2b3c4d-5e6f-7g8h-9i0j-1k2l3m4n5o6p')
+        >>> added_users = server.groups.add_users(group, '1a2b3c4d-5e6f-7g8h-9i0j-1k2l3m4n5o6p')
+        """
         """Adds multiple users to 1 group"""
         group_id = group_item.id if hasattr(group_item, "id") else group_item
         if not isinstance(group_id, str):
@@ -162,7 +477,7 @@ class Groups(QuerysetEndpoint[GroupItem]):
         add_req = RequestFactory.Group.add_users_req(users)
         server_response = self.post_request(url, add_req)
         users = UserItem.from_response(server_response.content, self.parent_srv.namespace)
-        logger.info("Added users to group (ID: {0})".format(group_item.id))
+        logger.info(f"Added users to group (ID: {group_item.id})")
         return users
 
     def filter(self, *invalid, page_size: Optional[int] = None, **kwargs) -> QuerySet[GroupItem]:

tableauserverclient/server/endpoint/groupsets_endpoint.py

@@ -1,4 +1,4 @@
-from typing import List, Literal, Optional, Tuple, TYPE_CHECKING, Union
+from typing import Literal, Optional, TYPE_CHECKING, Union
 
 from tableauserverclient.helpers.logging import logger
 from tableauserverclient.models.group_item import GroupItem
@@ -27,7 +27,7 @@ class GroupSets(QuerysetEndpoint[GroupSetItem]):
         self,
         request_options: Optional[RequestOptions] = None,
         result_level: Optional[Literal["members", "local"]] = None,
-    ) -> Tuple[List[GroupSetItem], PaginationItem]:
+    ) -> tuple[list[GroupSetItem], PaginationItem]:
         logger.info("Querying all group sets on site")
         url = self.baseurl
         if result_level:

tableauserverclient/server/endpoint/jobs_endpoint.py

@@ -11,28 +11,54 @@ from tableauserverclient.exponential_backoff import ExponentialBackoffTimer
 
 from tableauserverclient.helpers.logging import logger
 
-from typing import List, Optional, Tuple, Union
+from typing import Optional, Union
 
 
 class Jobs(QuerysetEndpoint[BackgroundJobItem]):
     @property
     def baseurl(self):
-        return "{0}/sites/{1}/jobs".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/jobs"
 
     @overload  # type: ignore[override]
     def get(self: Self, job_id: str, req_options: Optional[RequestOptionsBase] = None) -> JobItem:  # type: ignore[override]
         ...
 
     @overload  # type: ignore[override]
-    def get(self: Self, job_id: RequestOptionsBase, req_options: None) -> Tuple[List[BackgroundJobItem], PaginationItem]:  # type: ignore[override]
+    def get(self: Self, job_id: RequestOptionsBase, req_options: None) -> tuple[list[BackgroundJobItem], PaginationItem]:  # type: ignore[override]
         ...
 
     @overload  # type: ignore[override]
-    def get(self: Self, job_id: None, req_options: Optional[RequestOptionsBase]) -> Tuple[List[BackgroundJobItem], PaginationItem]:  # type: ignore[override]
+    def get(self: Self, job_id: None, req_options: Optional[RequestOptionsBase]) -> tuple[list[BackgroundJobItem], PaginationItem]:  # type: ignore[override]
         ...
 
     @api(version="2.6")
     def get(self, job_id=None, req_options=None):
+        """
+        Retrieve jobs for the site. Endpoint is paginated and will return a
+        list of jobs and pagination information. If a job_id is provided, the
+        method will return information about that specific job. Specifying a
+        job_id is deprecated and will be removed in a future version.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_jobs_tasks_and_schedules.htm#query_jobs
+
+        Parameters
+        ----------
+        job_id : str or RequestOptionsBase
+            The ID of the job to retrieve. If None, the method will return all
+            jobs for the site. If a RequestOptions object is provided, the
+            method will use the options to filter the jobs.
+
+        req_options : RequestOptionsBase
+            The request options to filter the jobs. If None, the method will
+            return all jobs for the site.
+
+        Returns
+        -------
+        tuple[list[BackgroundJobItem], PaginationItem] or JobItem
+            If a job_id is provided, the method will return a JobItem. If no
+            job_id is provided, the method will return a tuple containing a
+            list of BackgroundJobItems and a PaginationItem.
+        """
         # Backwards Compatibility fix until we rev the major version
         if job_id is not None and isinstance(job_id, str):
             import warnings
@@ -50,21 +76,104 @@ class Jobs(QuerysetEndpoint[BackgroundJobItem]):
 
     @api(version="3.1")
     def cancel(self, job_id: Union[str, JobItem]):
+        """
+        Cancels a job specified by job ID. To get a list of job IDs for jobs that are currently queued or in-progress, use the Query Jobs method.
+
+        The following jobs can be canceled using the Cancel Job method:
+
+        Full extract refresh
+        Incremental extract refresh
+        Subscription
+        Flow Run
+        Data Acceleration (Data acceleration is not available in Tableau Server 2022.1 (API 3.16) and later. See View Acceleration(Link opens in a new window).)
+        Bridge full extract refresh
+        Bridge incremental extract refresh
+        Queue upgrade Thumbnail (Job that puts the upgrade thumbnail job on the queue)
+        Upgrade Thumbnail
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_jobs_tasks_and_schedules.htm#cancel_job
+
+        Parameters
+        ----------
+        job_id : str or JobItem
+            The ID of the job to cancel. If a JobItem is provided, the method
+            will use the ID from the JobItem.
+
+        Returns
+        -------
+        None
+        """
         if isinstance(job_id, JobItem):
             job_id = job_id.id
         assert isinstance(job_id, str)
-        url = "{0}/{1}".format(self.baseurl, job_id)
+        url = f"{self.baseurl}/{job_id}"
         return self.put_request(url)
 
     @api(version="2.6")
     def get_by_id(self, job_id: str) -> JobItem:
+        """
+        Returns status information about an asynchronous process that is tracked
+        using a job. This method can be used to query jobs that are used to do
+        the following:
+
+        Import users from Active Directory (the result of a call to Create Group).
+        Synchronize an existing Tableau Server group with Active Directory (the result of a call to Update Group).
+        Run extract refresh tasks (the result of a call to Run Extract Refresh Task).
+        Publish a workbook asynchronously (the result of a call to Publish Workbook).
+        Run workbook or view subscriptions (the result of a call to Create Subscription or Update Subscription)
+        Run a flow task (the result of a call to Run Flow Task)
+        Status of Tableau Server site deletion (the result of a call to asynchronous Delete Site(Link opens in a new window) beginning API 3.18)
+        Note: To query a site deletion job, the server administrator must be first signed into the default site (contentUrl=" ").
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_jobs_tasks_and_schedules.htm#query_job
+
+        Parameters
+        ----------
+        job_id : str
+            The ID of the job to retrieve.
+
+        Returns
+        -------
+        JobItem
+            The JobItem object that contains information about the requested job.
+        """
         logger.info("Query for information about job " + job_id)
-        url = "{0}/{1}".format(self.baseurl, job_id)
+        url = f"{self.baseurl}/{job_id}"
         server_response = self.get_request(url)
         new_job = JobItem.from_response(server_response.content, self.parent_srv.namespace)[0]
         return new_job
 
     def wait_for_job(self, job_id: Union[str, JobItem], *, timeout: Optional[float] = None) -> JobItem:
+        """
+        Waits for a job to complete. The method will poll the server for the job
+        status until the job is completed. If the job is successful, the method
+        will return the JobItem. If the job fails, the method will raise a
+        JobFailedException. If the job is cancelled, the method will raise a
+        JobCancelledException.
+
+        Parameters
+        ----------
+        job_id : str or JobItem
+            The ID of the job to wait for. If a JobItem is provided, the method
+            will use the ID from the JobItem.
+
+        timeout : float | None
+            The maximum amount of time to wait for the job to complete. If None,
+            the method will wait indefinitely.
+
+        Returns
+        -------
+        JobItem
+            The JobItem object that contains information about the completed job.
+
+        Raises
+        ------
+        JobFailedException
+            If the job failed to complete.
+
+        JobCancelledException
+            If the job was cancelled.
+        """
         if isinstance(job_id, JobItem):
             job_id = job_id.id
         assert isinstance(job_id, str)
@@ -77,7 +186,7 @@ class Jobs(QuerysetEndpoint[BackgroundJobItem]):
             job = self.get_by_id(job_id)
             logger.debug(f"\tJob {job_id} progress={job.progress}")
 
-        logger.info("Job {} Completed: Finish Code: {} - Notes:{}".format(job_id, job.finish_code, job.notes))
+        logger.info(f"Job {job_id} Completed: Finish Code: {job.finish_code} - Notes:{job.notes}")
 
         if job.finish_code == JobItem.FinishCode.Success:
             return job

tableauserverclient/server/endpoint/linked_tasks_endpoint.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Tuple, Union
+from typing import Optional, Union
 
 from tableauserverclient.helpers.logging import logger
 from tableauserverclient.models.linked_tasks_item import LinkedTaskItem, LinkedTaskJobItem
@@ -18,7 +18,7 @@ class LinkedTasks(QuerysetEndpoint[LinkedTaskItem]):
         return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/tasks/linked"
 
     @api(version="3.15")
-    def get(self, req_options: Optional["RequestOptions"] = None) -> Tuple[List[LinkedTaskItem], PaginationItem]:
+    def get(self, req_options: Optional["RequestOptions"] = None) -> tuple[list[LinkedTaskItem], PaginationItem]:
         logger.info("Querying all linked tasks on site")
         url = self.baseurl
         server_response = self.get_request(url, req_options)