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

tableauserverclient/server/endpoint/flows_endpoint.py

@@ -9,11 +9,11 @@ from typing import Iterable, List, Optional, TYPE_CHECKING, Tuple, Union
 
 from tableauserverclient.helpers.headers import fix_filename
 
-from .dqw_endpoint import _DataQualityWarningEndpoint
-from .endpoint import QuerysetEndpoint, api
-from .exceptions import InternalServerError, MissingRequiredFieldError
-from .permissions_endpoint import _PermissionsEndpoint
-from .resource_tagger import _ResourceTagger
+from tableauserverclient.server.endpoint.dqw_endpoint import _DataQualityWarningEndpoint
+from tableauserverclient.server.endpoint.endpoint import QuerysetEndpoint, api
+from tableauserverclient.server.endpoint.exceptions import InternalServerError, MissingRequiredFieldError
+from tableauserverclient.server.endpoint.permissions_endpoint import _PermissionsEndpoint
+from tableauserverclient.server.endpoint.resource_tagger import _ResourceTagger, TaggingMixin
 from tableauserverclient.models import FlowItem, PaginationItem, ConnectionItem, JobItem
 from tableauserverclient.server import RequestFactory
 from tableauserverclient.filesys_helpers import (
@@ -22,6 +22,7 @@ from tableauserverclient.filesys_helpers import (
     get_file_type,
     get_file_object_size,
 )
+from tableauserverclient.server.query import QuerySet
 
 io_types_r = (io.BytesIO, io.BufferedReader)
 io_types_w = (io.BytesIO, io.BufferedWriter)
@@ -50,7 +51,7 @@ PathOrFileR = Union[FilePath, FileObjectR]
 PathOrFileW = Union[FilePath, FileObjectW]
 
 
-class Flows(QuerysetEndpoint):
+class Flows(QuerysetEndpoint[FlowItem], TaggingMixin[FlowItem]):
     def __init__(self, parent_srv):
         super(Flows, self).__init__(parent_srv)
         self._resource_tagger = _ResourceTagger(parent_srv)
@@ -265,16 +266,6 @@ class Flows(QuerysetEndpoint):
     def populate_permissions(self, item: FlowItem) -> None:
         self._permissions.populate(item)
 
-    @api(version="3.3")
-    def update_permission(self, item, permission_item):
-        import warnings
-
-        warnings.warn(
-            "Server.flows.update_permission is deprecated, " "please use Server.flows.update_permissions instead.",
-            DeprecationWarning,
-        )
-        self._permissions.update(item, permission_item)
-
     @api(version="3.3")
     def update_permissions(self, item: FlowItem, permission_item: Iterable["PermissionsRule"]) -> None:
         self._permissions.update(item, permission_item)
@@ -305,3 +296,39 @@ class Flows(QuerysetEndpoint):
         self, schedule_id: str, item: FlowItem
     ) -> List["AddResponse"]:  # actually should return a task
         return self.parent_srv.schedules.add_to_schedule(schedule_id, flow=item)
+
+    def filter(self, *invalid, page_size: Optional[int] = None, **kwargs) -> QuerySet[FlowItem]:
+        """
+        Queries the Tableau Server for items using the specified filters. Page
+        size can be specified to limit the number of items returned in a single
+        request. If not specified, the default page size is 100. Page size can
+        be an integer between 1 and 1000.
+
+        No positional arguments are allowed. All filters must be specified as
+        keyword arguments. If you use the equality operator, you can specify it
+        through <field_name>=<value>. If you want to use a different operator,
+        you can specify it through <field_name>__<operator>=<value>. Field
+        names can either be in snake_case or camelCase.
+
+        This endpoint supports the following fields and operators:
+
+
+        created_at=...
+        created_at__gt=...
+        created_at__gte=...
+        created_at__lt=...
+        created_at__lte=...
+        name=...
+        name__in=...
+        owner_name=...
+        project_id=...
+        project_name=...
+        project_name__in=...
+        updated=...
+        updated__gt=...
+        updated__gte=...
+        updated__lt=...
+        updated__lte=...
+        """
+
+        return super().filter(*invalid, page_size=page_size, **kwargs)

tableauserverclient/server/endpoint/groups_endpoint.py

@@ -1,27 +1,29 @@
 import logging
 
-from .endpoint import QuerysetEndpoint, api
-from .exceptions import MissingRequiredFieldError
+from tableauserverclient.server.endpoint.endpoint import QuerysetEndpoint, api
+from tableauserverclient.server.endpoint.exceptions import MissingRequiredFieldError
 from tableauserverclient.server import RequestFactory
 from tableauserverclient.models import GroupItem, UserItem, PaginationItem, JobItem
-from ..pager import Pager
+from tableauserverclient.server.pager import Pager
 
 from tableauserverclient.helpers.logging import logger
 
-from typing import List, Optional, TYPE_CHECKING, Tuple, Union
+from typing import Iterable, List, Optional, TYPE_CHECKING, Tuple, Union
+
+from tableauserverclient.server.query import QuerySet
 
 if TYPE_CHECKING:
-    from ..request_options import RequestOptions
+    from tableauserverclient.server.request_options import RequestOptions
 
 
-class Groups(QuerysetEndpoint):
+class Groups(QuerysetEndpoint[GroupItem]):
     @property
     def baseurl(self) -> str:
         return "{0}/sites/{1}/groups".format(self.parent_srv.baseurl, self.parent_srv.site_id)
 
-    # Gets all groups
     @api(version="2.0")
     def get(self, req_options: Optional["RequestOptions"] = None) -> Tuple[List[GroupItem], PaginationItem]:
+        """Gets all groups"""
         logger.info("Querying all groups on site")
         url = self.baseurl
         server_response = self.get_request(url, req_options)
@@ -29,9 +31,9 @@ class Groups(QuerysetEndpoint):
         all_group_items = GroupItem.from_response(server_response.content, self.parent_srv.namespace)
         return all_group_items, pagination_item
 
-    # Gets all users in a given group
     @api(version="2.0")
-    def populate_users(self, group_item, req_options: Optional["RequestOptions"] = None) -> None:
+    def populate_users(self, group_item: GroupItem, req_options: Optional["RequestOptions"] = None) -> None:
+        """Gets all users in a given group"""
         if not group_item.id:
             error = "Group item missing ID. Group must be retrieved from server first."
             raise MissingRequiredFieldError(error)
@@ -47,7 +49,7 @@ class Groups(QuerysetEndpoint):
         group_item._set_users(user_pager)
 
     def _get_users_for_group(
-        self, group_item, req_options: Optional["RequestOptions"] = None
+        self, group_item: GroupItem, req_options: Optional["RequestOptions"] = None
     ) -> Tuple[List[UserItem], PaginationItem]:
         url = "{0}/{1}/users".format(self.baseurl, group_item.id)
         server_response = self.get_request(url, req_options)
@@ -56,9 +58,9 @@ class Groups(QuerysetEndpoint):
         logger.info("Populated users for group (ID: {0})".format(group_item.id))
         return user_item, pagination_item
 
-    # Deletes 1 group by id
     @api(version="2.0")
     def delete(self, group_id: str) -> None:
+        """Deletes 1 group by id"""
         if not group_id:
             error = "Group ID undefined."
             raise ValueError(error)
@@ -67,21 +69,7 @@ class Groups(QuerysetEndpoint):
         logger.info("Deleted single group (ID: {0})".format(group_id))
 
     @api(version="2.0")
-    def update(
-        self, group_item: GroupItem, default_site_role: Optional[str] = None, as_job: bool = False
-    ) -> Union[GroupItem, JobItem]:
-        # (1/8/2021): Deprecated starting v0.15
-        if default_site_role is not None:
-            import warnings
-
-            warnings.simplefilter("always", DeprecationWarning)
-            warnings.warn(
-                'Groups.update(...default_site_role=""...) is deprecated, '
-                "please set the minimum_site_role field of GroupItem",
-                DeprecationWarning,
-            )
-            group_item.minimum_site_role = default_site_role
-
+    def update(self, group_item: GroupItem, as_job: bool = False) -> Union[GroupItem, JobItem]:
         url = "{0}/{1}".format(self.baseurl, group_item.id)
 
         if not group_item.id:
@@ -93,7 +81,7 @@ class Groups(QuerysetEndpoint):
         elif as_job:
             url = "?".join([url, "asJob=True"])
 
-        update_req = RequestFactory.Group.update_req(group_item, None)
+        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))
         if as_job:
@@ -101,17 +89,17 @@ class Groups(QuerysetEndpoint):
         else:
             return GroupItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
-    # Create a 'local' Tableau group
     @api(version="2.0")
     def create(self, group_item: GroupItem) -> GroupItem:
+        """Create a 'local' Tableau 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]
 
-    # Create a group based on Active Directory
     @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"""
         asJobparameter = "?asJob=true" if asJob else ""
         url = self.baseurl + asJobparameter
         create_req = RequestFactory.Group.create_ad_req(group_item)
@@ -121,9 +109,9 @@ class Groups(QuerysetEndpoint):
         else:
             return GroupItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
-    # Removes 1 user from 1 group
     @api(version="2.0")
     def remove_user(self, group_item: GroupItem, user_id: str) -> None:
+        """Removes 1 user from 1 group"""
         if not group_item.id:
             error = "Group item missing ID."
             raise MissingRequiredFieldError(error)
@@ -134,9 +122,22 @@ class Groups(QuerysetEndpoint):
         self.delete_request(url)
         logger.info("Removed user (id: {0}) from group (ID: {1})".format(user_id, group_item.id))
 
-    # Adds 1 user to 1 group
+    @api(version="3.21")
+    def remove_users(self, group_item: GroupItem, users: Iterable[Union[str, UserItem]]) -> None:
+        """Removes multiple users from 1 group"""
+        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}")
+
+        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))
+        return None
+
     @api(version="2.0")
     def add_user(self, group_item: GroupItem, user_id: str) -> UserItem:
+        """Adds 1 user to 1 group"""
         if not group_item.id:
             error = "Group item missing ID."
             raise MissingRequiredFieldError(error)
@@ -149,3 +150,56 @@ class Groups(QuerysetEndpoint):
         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))
         return user
+
+    @api(version="3.21")
+    def add_users(self, group_item: GroupItem, users: Iterable[Union[str, UserItem]]) -> List[UserItem]:
+        """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):
+            raise ValueError(f"Invalid group provided: {group_item}")
+
+        url = f"{self.baseurl}/{group_id}/users"
+        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))
+        return users
+
+    def filter(self, *invalid, page_size: Optional[int] = None, **kwargs) -> QuerySet[GroupItem]:
+        """
+        Queries the Tableau Server for items using the specified filters. Page
+        size can be specified to limit the number of items returned in a single
+        request. If not specified, the default page size is 100. Page size can
+        be an integer between 1 and 1000.
+
+        No positional arguments are allowed. All filters must be specified as
+        keyword arguments. If you use the equality operator, you can specify it
+        through <field_name>=<value>. If you want to use a different operator,
+        you can specify it through <field_name>__<operator>=<value>. Field
+        names can either be in snake_case or camelCase.
+
+        This endpoint supports the following fields and operators:
+
+
+        domain_name=...
+        domain_name__in=...
+        domain_nickname=...
+        domain_nickname__in=...
+        is_external_user_enabled=...
+        is_local=...
+        luid=...
+        luid__in=...
+        minimum_site_role=...
+        minimum_site_role__in=...
+        name__cieq=...
+        name=...
+        name__in=...
+        name__like=...
+        user_count=...
+        user_count__gt=...
+        user_count__gte=...
+        user_count__lt=...
+        user_count__lte=...
+        """
+
+        return super().filter(*invalid, page_size=page_size, **kwargs)

tableauserverclient/server/endpoint/groupsets_endpoint.py

@@ -0,0 +1,127 @@
+from typing import List, Literal, Optional, Tuple, TYPE_CHECKING, Union
+
+from tableauserverclient.helpers.logging import logger
+from tableauserverclient.models.group_item import GroupItem
+from tableauserverclient.models.groupset_item import GroupSetItem
+from tableauserverclient.models.pagination_item import PaginationItem
+from tableauserverclient.server.endpoint.endpoint import QuerysetEndpoint
+from tableauserverclient.server.query import QuerySet
+from tableauserverclient.server.request_options import RequestOptions
+from tableauserverclient.server.request_factory import RequestFactory
+from tableauserverclient.server.endpoint.endpoint import api
+
+if TYPE_CHECKING:
+    from tableauserverclient.server import Server
+
+
+class GroupSets(QuerysetEndpoint[GroupSetItem]):
+    def __init__(self, parent_srv: "Server") -> None:
+        super().__init__(parent_srv)
+
+    @property
+    def baseurl(self) -> str:
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/groupsets"
+
+    @api(version="3.22")
+    def get(
+        self,
+        request_options: Optional[RequestOptions] = None,
+        result_level: Optional[Literal["members", "local"]] = None,
+    ) -> Tuple[List[GroupSetItem], PaginationItem]:
+        logger.info("Querying all group sets on site")
+        url = self.baseurl
+        if result_level:
+            url += f"?resultlevel={result_level}"
+        server_response = self.get_request(url, request_options)
+        pagination_item = PaginationItem.from_response(server_response.content, self.parent_srv.namespace)
+        all_group_set_items = GroupSetItem.from_response(server_response.content, self.parent_srv.namespace)
+        return all_group_set_items, pagination_item
+
+    @api(version="3.22")
+    def get_by_id(self, groupset_id: str) -> GroupSetItem:
+        logger.info(f"Querying group set (ID: {groupset_id})")
+        url = f"{self.baseurl}/{groupset_id}"
+        server_response = self.get_request(url)
+        all_group_set_items = GroupSetItem.from_response(server_response.content, self.parent_srv.namespace)
+        return all_group_set_items[0]
+
+    @api(version="3.22")
+    def create(self, groupset_item: GroupSetItem) -> GroupSetItem:
+        logger.info(f"Creating group set (name: {groupset_item.name})")
+        url = self.baseurl
+        request = RequestFactory.GroupSet.create_request(groupset_item)
+        server_response = self.post_request(url, request)
+        created_groupset = GroupSetItem.from_response(server_response.content, self.parent_srv.namespace)
+        return created_groupset[0]
+
+    @api(version="3.22")
+    def add_group(self, groupset_item: GroupSetItem, group: Union[GroupItem, str]) -> None:
+        group_id = group.id if isinstance(group, GroupItem) else group
+        logger.info(f"Adding group (ID: {group_id}) to group set (ID: {groupset_item.id})")
+        url = f"{self.baseurl}/{groupset_item.id}/groups/{group_id}"
+        _ = self.put_request(url)
+        return None
+
+    @api(version="3.22")
+    def remove_group(self, groupset_item: GroupSetItem, group: Union[GroupItem, str]) -> None:
+        group_id = group.id if isinstance(group, GroupItem) else group
+        logger.info(f"Removing group (ID: {group_id}) from group set (ID: {groupset_item.id})")
+        url = f"{self.baseurl}/{groupset_item.id}/groups/{group_id}"
+        _ = self.delete_request(url)
+        return None
+
+    @api(version="3.22")
+    def delete(self, groupset: Union[GroupSetItem, str]) -> None:
+        groupset_id = groupset.id if isinstance(groupset, GroupSetItem) else groupset
+        logger.info(f"Deleting group set (ID: {groupset_id})")
+        url = f"{self.baseurl}/{groupset_id}"
+        _ = self.delete_request(url)
+        return None
+
+    @api(version="3.22")
+    def update(self, groupset: GroupSetItem) -> GroupSetItem:
+        logger.info(f"Updating group set (ID: {groupset.id})")
+        url = f"{self.baseurl}/{groupset.id}"
+        request = RequestFactory.GroupSet.update_request(groupset)
+        server_response = self.put_request(url, request)
+        updated_groupset = GroupSetItem.from_response(server_response.content, self.parent_srv.namespace)
+        return updated_groupset[0]
+
+    def filter(self, *invalid, page_size: Optional[int] = None, **kwargs) -> QuerySet[GroupSetItem]:
+        """
+        Queries the Tableau Server for items using the specified filters. Page
+        size can be specified to limit the number of items returned in a single
+        request. If not specified, the default page size is 100. Page size can
+        be an integer between 1 and 1000.
+
+        No positional arguments are allowed. All filters must be specified as
+        keyword arguments. If you use the equality operator, you can specify it
+        through <field_name>=<value>. If you want to use a different operator,
+        you can specify it through <field_name>__<operator>=<value>. Field
+        names can either be in snake_case or camelCase.
+
+        This endpoint supports the following fields and operators:
+
+
+        domain_name=...
+        domain_name__in=...
+        domain_nickname=...
+        domain_nickname__in=...
+        is_external_user_enabled=...
+        is_local=...
+        luid=...
+        luid__in=...
+        minimum_site_role=...
+        minimum_site_role__in=...
+        name__cieq=...
+        name=...
+        name__in=...
+        name__like=...
+        user_count=...
+        user_count__gt=...
+        user_count__gte=...
+        user_count__lt=...
+        user_count__lte=...
+        """
+
+        return super().filter(*invalid, page_size=page_size, **kwargs)

tableauserverclient/server/endpoint/jobs_endpoint.py

@@ -1,9 +1,12 @@
 import logging
+from typing_extensions import Self, overload
+
 
-from .endpoint import QuerysetEndpoint, api
-from .exceptions import JobCancelledException, JobFailedException
 from tableauserverclient.models import JobItem, BackgroundJobItem, PaginationItem
-from ..request_options import RequestOptionsBase
+from tableauserverclient.server.endpoint.endpoint import QuerysetEndpoint, api
+from tableauserverclient.server.endpoint.exceptions import JobCancelledException, JobFailedException
+from tableauserverclient.server.query import QuerySet
+from tableauserverclient.server.request_options import RequestOptionsBase
 from tableauserverclient.exponential_backoff import ExponentialBackoffTimer
 
 from tableauserverclient.helpers.logging import logger
@@ -11,15 +14,25 @@ from tableauserverclient.helpers.logging import logger
 from typing import List, Optional, Tuple, Union
 
 
-class Jobs(QuerysetEndpoint):
+class Jobs(QuerysetEndpoint[BackgroundJobItem]):
     @property
     def baseurl(self):
         return "{0}/sites/{1}/jobs".format(self.parent_srv.baseurl, self.parent_srv.site_id)
 
+    @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]
+        ...
+
+    @overload  # 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: Optional[str] = None, req_options: Optional[RequestOptionsBase] = None
-    ) -> Tuple[List[BackgroundJobItem], PaginationItem]:
+    def get(self, job_id=None, req_options=None):
         # Backwards Compatibility fix until we rev the major version
         if job_id is not None and isinstance(job_id, str):
             import warnings
@@ -74,3 +87,57 @@ class Jobs(QuerysetEndpoint):
             raise JobCancelledException(job)
         else:
             raise AssertionError("Unexpected finish_code in job", job)
+
+    def filter(self, *invalid, page_size: Optional[int] = None, **kwargs) -> QuerySet[BackgroundJobItem]:
+        """
+        Queries the Tableau Server for items using the specified filters. Page
+        size can be specified to limit the number of items returned in a single
+        request. If not specified, the default page size is 100. Page size can
+        be an integer between 1 and 1000.
+
+        No positional arguments are allowed. All filters must be specified as
+        keyword arguments. If you use the equality operator, you can specify it
+        through <field_name>=<value>. If you want to use a different operator,
+        you can specify it through <field_name>__<operator>=<value>. Field
+        names can either be in snake_case or camelCase.
+
+        This endpoint supports the following fields and operators:
+
+
+        args__has=...
+        completed_at=...
+        completed_at__gt=...
+        completed_at__gte=...
+        completed_at__lt=...
+        completed_at__lte=...
+        created_at=...
+        created_at__gt=...
+        created_at__gte=...
+        created_at__lt=...
+        created_at__lte=...
+        job_type=...
+        job_type__in=...
+        notes__has=...
+        priority=...
+        priority__gt=...
+        priority__gte=...
+        priority__lt=...
+        priority__lte=...
+        progress=...
+        progress__gt=...
+        progress__gte=...
+        progress__lt=...
+        progress__lte=...
+        started_at=...
+        started_at__gt=...
+        started_at__gte=...
+        started_at__lt=...
+        started_at__lte=...
+        status=...
+        subtitle=...
+        subtitle__has=...
+        title=...
+        title__has=...
+        """
+
+        return super().filter(*invalid, page_size=page_size, **kwargs)

tableauserverclient/server/endpoint/linked_tasks_endpoint.py

@@ -0,0 +1,45 @@
+from typing import List, Optional, Tuple, Union
+
+from tableauserverclient.helpers.logging import logger
+from tableauserverclient.models.linked_tasks_item import LinkedTaskItem, LinkedTaskJobItem
+from tableauserverclient.models.pagination_item import PaginationItem
+from tableauserverclient.server.endpoint.endpoint import QuerysetEndpoint, api
+from tableauserverclient.server.request_factory import RequestFactory
+from tableauserverclient.server.request_options import RequestOptions
+
+
+class LinkedTasks(QuerysetEndpoint[LinkedTaskItem]):
+    def __init__(self, parent_srv):
+        super().__init__(parent_srv)
+        self._parent_srv = parent_srv
+
+    @property
+    def baseurl(self) -> str:
+        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]:
+        logger.info("Querying all linked tasks 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_group_items = LinkedTaskItem.from_response(server_response.content, self.parent_srv.namespace)
+        return all_group_items, pagination_item
+
+    @api(version="3.15")
+    def get_by_id(self, linked_task: Union[LinkedTaskItem, str]) -> LinkedTaskItem:
+        task_id = getattr(linked_task, "id", linked_task)
+        logger.info("Querying all linked tasks on site")
+        url = f"{self.baseurl}/{task_id}"
+        server_response = self.get_request(url)
+        all_group_items = LinkedTaskItem.from_response(server_response.content, self.parent_srv.namespace)
+        return all_group_items[0]
+
+    @api(version="3.15")
+    def run_now(self, linked_task: Union[LinkedTaskItem, str]) -> LinkedTaskJobItem:
+        task_id = getattr(linked_task, "id", linked_task)
+        logger.info(f"Running linked task {task_id} now")
+        url = f"{self.baseurl}/{task_id}/runNow"
+        empty_req = RequestFactory.Empty.empty_req()
+        server_response = self.post_request(url, empty_req)
+        return LinkedTaskJobItem.from_response(server_response.content, self.parent_srv.namespace)

tableauserverclient/server/endpoint/metadata_endpoint.py

@@ -42,9 +42,9 @@ def extract_values(obj, key):
 
 
 def get_page_info(result):
-    next_page = extract_values(result, "hasNextPage").pop()
-    cursor = extract_values(result, "endCursor").pop()
-    return next_page, cursor
+    next_page = extract_values(result, "hasNextPage")
+    cursor = extract_values(result, "endCursor")
+    return next_page.pop() if next_page else None, cursor.pop() if cursor else None
 
 
 class Metadata(Endpoint):

tableauserverclient/server/endpoint/metrics_endpoint.py

@@ -18,7 +18,7 @@ if TYPE_CHECKING:
 from tableauserverclient.helpers.logging import logger
 
 
-class Metrics(QuerysetEndpoint):
+class Metrics(QuerysetEndpoint[MetricItem]):
     def __init__(self, parent_srv: "Server") -> None:
         super(Metrics, self).__init__(parent_srv)
         self._resource_tagger = _ResourceTagger(parent_srv)