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

tableauserverclient/server/endpoint/groups_endpoint.py

@@ -1,17 +1,19 @@
 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[GroupItem]):
@@ -19,9 +21,9 @@ class Groups(QuerysetEndpoint[GroupItem]):
     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[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,7 +49,7 @@ class Groups(QuerysetEndpoint[GroupItem]):
         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[GroupItem]):
         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)
@@ -87,17 +89,17 @@ class Groups(QuerysetEndpoint[GroupItem]):
         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,9 +109,9 @@ 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)
@@ -120,9 +122,22 @@ class Groups(QuerysetEndpoint[GroupItem]):
         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)
@@ -135,3 +150,56 @@ class Groups(QuerysetEndpoint[GroupItem]):
         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[JobItem]):
+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[JobItem]):
             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/projects_endpoint.py

@@ -9,6 +9,8 @@ from tableauserverclient.models import ProjectItem, PaginationItem, Resource
 
 from typing import List, Optional, Tuple, TYPE_CHECKING
 
+from tableauserverclient.server.query import QuerySet
+
 if TYPE_CHECKING:
     from tableauserverclient.server.server import Server
     from tableauserverclient.server.request_options import RequestOptions
@@ -154,3 +156,44 @@ class Projects(QuerysetEndpoint[ProjectItem]):
     @api(version="3.4")
     def delete_lens_default_permissions(self, item, rule):
         self._default_permissions.delete_default_permission(item, rule, Resource.Lens)
+
+    def filter(self, *invalid, page_size: Optional[int] = None, **kwargs) -> QuerySet[ProjectItem]:
+        """
+        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_domain=...
+        owner_domain__in=...
+        owner_email=...
+        owner_email__in=...
+        owner_name=...
+        owner_name__in=...
+        parent_project_id=...
+        parent_project_id__in=...
+        top_level_project=...
+        updated_at=...
+        updated_at__gt=...
+        updated_at__gte=...
+        updated_at__lt=...
+        updated_at__lte=...
+        """
+
+        return super().filter(*invalid, page_size=page_size, **kwargs)

tableauserverclient/server/endpoint/resource_tagger.py

@@ -1,14 +1,25 @@
+import abc
 import copy
+from typing import Generic, Iterable, Optional, Protocol, Set, TypeVar, Union, TYPE_CHECKING, runtime_checkable
 import urllib.parse
 
-from .endpoint import Endpoint
-from .exceptions import ServerResponseError
-from ..exceptions import EndpointUnavailableError
+from tableauserverclient.server.endpoint.endpoint import Endpoint, api
+from tableauserverclient.server.endpoint.exceptions import ServerResponseError
+from tableauserverclient.server.exceptions import EndpointUnavailableError
 from tableauserverclient.server import RequestFactory
 from tableauserverclient.models import TagItem
 
 from tableauserverclient.helpers.logging import logger
 
+if TYPE_CHECKING:
+    from tableauserverclient.models.column_item import ColumnItem
+    from tableauserverclient.models.database_item import DatabaseItem
+    from tableauserverclient.models.datasource_item import DatasourceItem
+    from tableauserverclient.models.flow_item import FlowItem
+    from tableauserverclient.models.table_item import TableItem
+    from tableauserverclient.models.workbook_item import WorkbookItem
+    from tableauserverclient.server.server import Server
+
 
 class _ResourceTagger(Endpoint):
     # Add new tags to resource
@@ -49,3 +60,124 @@ class _ResourceTagger(Endpoint):
                 resource_item.tags = self._add_tags(baseurl, resource_item.id, add_set)
             resource_item._initial_tags = copy.copy(resource_item.tags)
         logger.info("Updated tags to {0}".format(resource_item.tags))
+
+
+class Response(Protocol):
+    content: bytes
+
+
+@runtime_checkable
+class Taggable(Protocol):
+    tags: Set[str]
+    _initial_tags: Set[str]
+
+    @property
+    def id(self) -> Optional[str]:
+        pass
+
+
+T = TypeVar("T")
+
+
+class TaggingMixin(abc.ABC, Generic[T]):
+    parent_srv: "Server"
+
+    @property
+    @abc.abstractmethod
+    def baseurl(self) -> str:
+        pass
+
+    @abc.abstractmethod
+    def put_request(self, url, request) -> Response:
+        pass
+
+    @abc.abstractmethod
+    def delete_request(self, url) -> None:
+        pass
+
+    def add_tags(self, item: Union[T, str], tags: Union[Iterable[str], str]) -> Set[str]:
+        item_id = getattr(item, "id", item)
+
+        if not isinstance(item_id, str):
+            raise ValueError("ID not found.")
+
+        if isinstance(tags, str):
+            tag_set = set([tags])
+        else:
+            tag_set = set(tags)
+
+        url = f"{self.baseurl}/{item_id}/tags"
+        add_req = RequestFactory.Tag.add_req(tag_set)
+        server_response = self.put_request(url, add_req)
+        return TagItem.from_response(server_response.content, self.parent_srv.namespace)
+
+    def delete_tags(self, item: Union[T, str], tags: Union[Iterable[str], str]) -> None:
+        item_id = getattr(item, "id", item)
+
+        if not isinstance(item_id, str):
+            raise ValueError("ID not found.")
+
+        if isinstance(tags, str):
+            tag_set = set([tags])
+        else:
+            tag_set = set(tags)
+
+        for tag in tag_set:
+            encoded_tag_name = urllib.parse.quote(tag)
+            url = f"{self.baseurl}/{item_id}/tags/{encoded_tag_name}"
+            self.delete_request(url)
+
+    def update_tags(self, item: T) -> None:
+        if (initial_tags := getattr(item, "_initial_tags", None)) is None:
+            raise ValueError(f"{item} does not have initial tags.")
+        if (tags := getattr(item, "tags", None)) is None:
+            raise ValueError(f"{item} does not have tags.")
+        if tags == initial_tags:
+            return
+
+        add_set = tags - initial_tags
+        remove_set = initial_tags - tags
+        self.delete_tags(item, remove_set)
+        if add_set:
+            tags = self.add_tags(item, add_set)
+            setattr(item, "tags", tags)
+
+        setattr(item, "_initial_tags", copy.copy(tags))
+        logger.info(f"Updated tags to {tags}")
+
+
+content = Iterable[Union["ColumnItem", "DatabaseItem", "DatasourceItem", "FlowItem", "TableItem", "WorkbookItem"]]
+
+
+class Tags(Endpoint):
+    def __init__(self, parent_srv: "Server"):
+        super().__init__(parent_srv)
+
+    @property
+    def baseurl(self):
+        return f"{self.parent_srv.baseurl}/tags"
+
+    @api(version="3.9")
+    def batch_add(self, tags: Union[Iterable[str], str], content: content) -> Set[str]:
+        if isinstance(tags, str):
+            tag_set = set([tags])
+        else:
+            tag_set = set(tags)
+
+        url = f"{self.baseurl}:batchCreate"
+        batch_create_req = RequestFactory.Tag.batch_create(tag_set, content)
+        server_response = self.put_request(url, batch_create_req)
+        return TagItem.from_response(server_response.content, self.parent_srv.namespace)
+
+    @api(version="3.9")
+    def batch_delete(self, tags: Union[Iterable[str], str], content: content) -> Set[str]:
+        if isinstance(tags, str):
+            tag_set = set([tags])
+        else:
+            tag_set = set(tags)
+
+        url = f"{self.baseurl}:batchDelete"
+        # The batch delete XML is the same as the batch create XML.
+        batch_delete_req = RequestFactory.Tag.batch_create(tag_set, content)
+        server_response = self.put_request(url, batch_delete_req)
+        return TagItem.from_response(server_response.content, self.parent_srv.namespace)