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

tableauserverclient/server/endpoint/flows_endpoint.py

@@ -5,15 +5,16 @@ import logging
 import os
 from contextlib import closing
 from pathlib import Path
-from typing import Iterable, List, Optional, TYPE_CHECKING, Tuple, Union
+from typing import Optional, TYPE_CHECKING, Union
+from collections.abc import Iterable
 
 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 +23,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,20 +52,20 @@ PathOrFileR = Union[FilePath, FileObjectR]
 PathOrFileW = Union[FilePath, FileObjectW]
 
 
-class Flows(QuerysetEndpoint[FlowItem]):
+class Flows(QuerysetEndpoint[FlowItem], TaggingMixin[FlowItem]):
     def __init__(self, parent_srv):
-        super(Flows, self).__init__(parent_srv)
+        super().__init__(parent_srv)
         self._resource_tagger = _ResourceTagger(parent_srv)
         self._permissions = _PermissionsEndpoint(parent_srv, lambda: self.baseurl)
         self._data_quality_warnings = _DataQualityWarningEndpoint(self.parent_srv, "flow")
 
     @property
     def baseurl(self) -> str:
-        return "{0}/sites/{1}/flows".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/flows"
 
     # Get all flows
     @api(version="3.3")
-    def get(self, req_options: Optional["RequestOptions"] = None) -> Tuple[List[FlowItem], PaginationItem]:
+    def get(self, req_options: Optional["RequestOptions"] = None) -> tuple[list[FlowItem], PaginationItem]:
         logger.info("Querying all flows on site")
         url = self.baseurl
         server_response = self.get_request(url, req_options)
@@ -77,8 +79,8 @@ class Flows(QuerysetEndpoint[FlowItem]):
         if not flow_id:
             error = "Flow ID undefined."
             raise ValueError(error)
-        logger.info("Querying single flow (ID: {0})".format(flow_id))
-        url = "{0}/{1}".format(self.baseurl, flow_id)
+        logger.info(f"Querying single flow (ID: {flow_id})")
+        url = f"{self.baseurl}/{flow_id}"
         server_response = self.get_request(url)
         return FlowItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
@@ -93,10 +95,10 @@ class Flows(QuerysetEndpoint[FlowItem]):
             return self._get_flow_connections(flow_item)
 
         flow_item._set_connections(connections_fetcher)
-        logger.info("Populated connections for flow (ID: {0})".format(flow_item.id))
+        logger.info(f"Populated connections for flow (ID: {flow_item.id})")
 
-    def _get_flow_connections(self, flow_item, req_options: Optional["RequestOptions"] = None) -> List[ConnectionItem]:
-        url = "{0}/{1}/connections".format(self.baseurl, flow_item.id)
+    def _get_flow_connections(self, flow_item, req_options: Optional["RequestOptions"] = None) -> list[ConnectionItem]:
+        url = f"{self.baseurl}/{flow_item.id}/connections"
         server_response = self.get_request(url, req_options)
         connections = ConnectionItem.from_response(server_response.content, self.parent_srv.namespace)
         return connections
@@ -107,9 +109,9 @@ class Flows(QuerysetEndpoint[FlowItem]):
         if not flow_id:
             error = "Flow ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}".format(self.baseurl, flow_id)
+        url = f"{self.baseurl}/{flow_id}"
         self.delete_request(url)
-        logger.info("Deleted single flow (ID: {0})".format(flow_id))
+        logger.info(f"Deleted single flow (ID: {flow_id})")
 
     # Download 1 flow by id
     @api(version="3.3")
@@ -117,7 +119,7 @@ class Flows(QuerysetEndpoint[FlowItem]):
         if not flow_id:
             error = "Flow ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}/content".format(self.baseurl, flow_id)
+        url = f"{self.baseurl}/{flow_id}/content"
 
         with closing(self.get_request(url, parameters={"stream": True})) as server_response:
             m = Message()
@@ -136,7 +138,7 @@ class Flows(QuerysetEndpoint[FlowItem]):
                         f.write(chunk)
                 return_path = os.path.abspath(download_path)
 
-        logger.info("Downloaded flow to {0} (ID: {1})".format(return_path, flow_id))
+        logger.info(f"Downloaded flow to {return_path} (ID: {flow_id})")
         return return_path
 
     # Update flow
@@ -149,28 +151,28 @@ class Flows(QuerysetEndpoint[FlowItem]):
         self._resource_tagger.update_tags(self.baseurl, flow_item)
 
         # Update the flow itself
-        url = "{0}/{1}".format(self.baseurl, flow_item.id)
+        url = f"{self.baseurl}/{flow_item.id}"
         update_req = RequestFactory.Flow.update_req(flow_item)
         server_response = self.put_request(url, update_req)
-        logger.info("Updated flow item (ID: {0})".format(flow_item.id))
+        logger.info(f"Updated flow item (ID: {flow_item.id})")
         updated_flow = copy.copy(flow_item)
         return updated_flow._parse_common_elements(server_response.content, self.parent_srv.namespace)
 
     # Update flow connections
     @api(version="3.3")
     def update_connection(self, flow_item: FlowItem, connection_item: ConnectionItem) -> ConnectionItem:
-        url = "{0}/{1}/connections/{2}".format(self.baseurl, flow_item.id, connection_item.id)
+        url = f"{self.baseurl}/{flow_item.id}/connections/{connection_item.id}"
 
         update_req = RequestFactory.Connection.update_req(connection_item)
         server_response = self.put_request(url, update_req)
         connection = ConnectionItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
-        logger.info("Updated flow item (ID: {0} & connection item {1}".format(flow_item.id, connection_item.id))
+        logger.info(f"Updated flow item (ID: {flow_item.id} & connection item {connection_item.id}")
         return connection
 
     @api(version="3.3")
     def refresh(self, flow_item: FlowItem) -> JobItem:
-        url = "{0}/{1}/run".format(self.baseurl, flow_item.id)
+        url = f"{self.baseurl}/{flow_item.id}/run"
         empty_req = RequestFactory.Empty.empty_req()
         server_response = self.post_request(url, empty_req)
         new_job = JobItem.from_response(server_response.content, self.parent_srv.namespace)[0]
@@ -179,7 +181,7 @@ class Flows(QuerysetEndpoint[FlowItem]):
     # Publish flow
     @api(version="3.3")
     def publish(
-        self, flow_item: FlowItem, file: PathOrFileR, mode: str, connections: Optional[List[ConnectionItem]] = None
+        self, flow_item: FlowItem, file: PathOrFileR, mode: str, connections: Optional[list[ConnectionItem]] = None
     ) -> FlowItem:
         if not mode or not hasattr(self.parent_srv.PublishMode, mode):
             error = "Invalid mode defined."
@@ -188,7 +190,7 @@ class Flows(QuerysetEndpoint[FlowItem]):
         if isinstance(file, (str, os.PathLike)):
             if not os.path.isfile(file):
                 error = "File path does not lead to an existing file."
-                raise IOError(error)
+                raise OSError(error)
 
             filename = os.path.basename(file)
             file_extension = os.path.splitext(filename)[1][1:]
@@ -212,30 +214,30 @@ class Flows(QuerysetEndpoint[FlowItem]):
             elif file_type == "xml":
                 file_extension = "tfl"
             else:
-                error = "Unsupported file type {}!".format(file_type)
+                error = f"Unsupported file type {file_type}!"
                 raise ValueError(error)
 
             # Generate filename for file object.
             # This is needed when publishing the flow in a single request
-            filename = "{}.{}".format(flow_item.name, file_extension)
+            filename = f"{flow_item.name}.{file_extension}"
             file_size = get_file_object_size(file)
 
         else:
             raise TypeError("file should be a filepath or file object.")
 
         # Construct the url with the defined mode
-        url = "{0}?flowType={1}".format(self.baseurl, file_extension)
+        url = f"{self.baseurl}?flowType={file_extension}"
         if mode == self.parent_srv.PublishMode.Overwrite or mode == self.parent_srv.PublishMode.Append:
-            url += "&{0}=true".format(mode.lower())
+            url += f"&{mode.lower()}=true"
 
         # Determine if chunking is required (64MB is the limit for single upload method)
         if file_size >= FILESIZE_LIMIT:
-            logger.info("Publishing {0} to server with chunking method (flow over 64MB)".format(filename))
+            logger.info(f"Publishing {filename} to server with chunking method (flow over 64MB)")
             upload_session_id = self.parent_srv.fileuploads.upload(file)
-            url = "{0}&uploadSessionId={1}".format(url, upload_session_id)
+            url = f"{url}&uploadSessionId={upload_session_id}"
             xml_request, content_type = RequestFactory.Flow.publish_req_chunked(flow_item, connections)
         else:
-            logger.info("Publishing {0} to server".format(filename))
+            logger.info(f"Publishing {filename} to server")
 
             if isinstance(file, (str, Path)):
                 with open(file, "rb") as f:
@@ -258,7 +260,7 @@ class Flows(QuerysetEndpoint[FlowItem]):
             raise err
         else:
             new_flow = FlowItem.from_response(server_response.content, self.parent_srv.namespace)[0]
-            logger.info("Published {0} (ID: {1})".format(filename, new_flow.id))
+            logger.info(f"Published {filename} (ID: {new_flow.id})")
             return new_flow
 
     @api(version="3.3")
@@ -293,5 +295,41 @@ class Flows(QuerysetEndpoint[FlowItem]):
     @api(version="3.3")
     def schedule_flow_run(
         self, schedule_id: str, item: FlowItem
-    ) -> List["AddResponse"]:  # actually should return a task
+    ) -> 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,30 @@
 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 Optional, TYPE_CHECKING, Union
+from collections.abc import Iterable
+
+from tableauserverclient.server.query import QuerySet
 
 if TYPE_CHECKING:
-    from ..request_options import RequestOptions
+    from tableauserverclient.server.request_options import RequestOptions
 
 
 class Groups(QuerysetEndpoint[GroupItem]):
     @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"
 
-    # Gets all groups
     @api(version="2.0")
-    def get(self, req_options: Optional["RequestOptions"] = None) -> Tuple[List[GroupItem], PaginationItem]:
+    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 +32,9 @@ class Groups(QuerysetEndpoint[GroupItem]):
         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,28 +50,28 @@ class Groups(QuerysetEndpoint[GroupItem]):
         group_item._set_users(user_pager)
 
     def _get_users_for_group(
-        self, group_item, req_options: Optional["RequestOptions"] = None
-    ) -> Tuple[List[UserItem], PaginationItem]:
-        url = "{0}/{1}/users".format(self.baseurl, group_item.id)
+        self, group_item: GroupItem, req_options: Optional["RequestOptions"] = None
+    ) -> 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
 
-    # 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)
-        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})")
 
     @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)
+        url = f"{self.baseurl}/{group_item.id}"
 
         if not group_item.id:
             error = "Group item missing ID."
@@ -81,23 +84,23 @@ 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:
             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)
@@ -107,31 +110,97 @@ class Groups(QuerysetEndpoint[GroupItem]):
         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)
         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"""
+        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(f"Removed users to group (ID: {group_item.id})")
+        return None
 
-    # Adds 1 user to 1 group
     @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)
         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]:
+        """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(f"Added users to group (ID: {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 Literal, Optional, 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)