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

tableauserverclient/server/endpoint/auth_endpoint.py

@@ -4,9 +4,9 @@ import warnings
 
 from defusedxml.ElementTree import fromstring
 
-from .endpoint import Endpoint, api
-from .exceptions import ServerResponseError
-from ..request_factory import RequestFactory
+from tableauserverclient.server.endpoint.endpoint import Endpoint, api
+from tableauserverclient.server.endpoint.exceptions import ServerResponseError
+from tableauserverclient.server.request_factory import RequestFactory
 
 from tableauserverclient.helpers.logging import logger
 
@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 
 
 class Auth(Endpoint):
-    class contextmgr(object):
+    class contextmgr:
         def __init__(self, callback):
             self._callback = callback
 
@@ -28,7 +28,7 @@ class Auth(Endpoint):
 
     @property
     def baseurl(self) -> str:
-        return "{0}/auth".format(self.parent_srv.baseurl)
+        return f"{self.parent_srv.baseurl}/auth"
 
     @api(version="2.0")
     def sign_in(self, auth_req: "Credentials") -> contextmgr:
@@ -41,8 +41,32 @@ class Auth(Endpoint):
         optionally a user_id to impersonate.
 
         Creates a context manager that will sign out of the server upon exit.
+
+        Parameters
+        ----------
+        auth_req : Credentials
+            The credentials object to use for signing in. Can be a TableauAuth,
+            PersonalAccessTokenAuth, or JWTAuth object.
+
+        Returns
+        -------
+        contextmgr
+            A context manager that will sign out of the server upon exit.
+
+        Examples
+        --------
+        >>> import tableauserverclient as TSC
+
+        >>> # create an auth object
+        >>> tableau_auth = TSC.TableauAuth('USERNAME', 'PASSWORD')
+
+        >>> # create an instance for your server
+        >>> server = TSC.Server('https://SERVER_URL')
+
+        >>> # call the sign-in method with the auth object
+        >>> server.auth.sign_in(tableau_auth)
         """
-        url = "{0}/{1}".format(self.baseurl, "signin")
+        url = f"{self.baseurl}/signin"
         signin_req = RequestFactory.Auth.signin_req(auth_req)
         server_response = self.parent_srv.session.post(
             url, data=signin_req, **self.parent_srv.http_options, allow_redirects=False
@@ -63,22 +87,25 @@ class Auth(Endpoint):
         user_id = parsed_response.find(".//t:user", namespaces=self.parent_srv.namespace).get("id", None)
         auth_token = parsed_response.find("t:credentials", namespaces=self.parent_srv.namespace).get("token", None)
         self.parent_srv._set_auth(site_id, user_id, auth_token)
-        logger.info("Signed into {0} as user with id {1}".format(self.parent_srv.server_address, user_id))
+        logger.info(f"Signed into {self.parent_srv.server_address} as user with id {user_id}")
         return Auth.contextmgr(self.sign_out)
 
     # We use the same request that username/password login uses for all auth types.
     # The distinct methods are mostly useful for explicitly showing api version support for each auth type
     @api(version="3.6")
     def sign_in_with_personal_access_token(self, auth_req: "Credentials") -> contextmgr:
+        """Passthrough to sign_in method"""
         return self.sign_in(auth_req)
 
     @api(version="3.17")
     def sign_in_with_json_web_token(self, auth_req: "Credentials") -> contextmgr:
+        """Passthrough to sign_in method"""
         return self.sign_in(auth_req)
 
     @api(version="2.0")
     def sign_out(self) -> None:
-        url = "{0}/{1}".format(self.baseurl, "signout")
+        """Sign out of current session."""
+        url = f"{self.baseurl}/signout"
         # If there are no auth tokens you're already signed out. No-op
         if not self.parent_srv.is_signed_in():
             return
@@ -88,7 +115,34 @@ class Auth(Endpoint):
 
     @api(version="2.6")
     def switch_site(self, site_item: "SiteItem") -> contextmgr:
-        url = "{0}/{1}".format(self.baseurl, "switchSite")
+        """
+        Switch to a different site on the server. This will sign out of the
+        current site and sign in to the new site. If used as a context manager,
+        will sign out of the new site upon exit.
+
+        Parameters
+        ----------
+        site_item : SiteItem
+            The site to switch to.
+
+        Returns
+        -------
+        contextmgr
+            A context manager that will sign out of the new site upon exit.
+
+        Examples
+        --------
+        >>> import tableauserverclient as TSC
+
+        >>> # Find the site you want to switch to
+        >>> new_site = server.sites.get_by_id("9a8b7c6d-5e4f-3a2b-1c0d-9e8f7a6b5c4d")
+        >>> # switch to the new site
+        >>> with server.auth.switch_site(new_site):
+        >>>     # do something on the new site
+        >>>     pass
+
+        """
+        url = f"{self.baseurl}/switchSite"
         switch_req = RequestFactory.Auth.switch_req(site_item.content_url)
         try:
             server_response = self.post_request(url, switch_req)
@@ -104,11 +158,14 @@ class Auth(Endpoint):
         user_id = parsed_response.find(".//t:user", namespaces=self.parent_srv.namespace).get("id", None)
         auth_token = parsed_response.find("t:credentials", namespaces=self.parent_srv.namespace).get("token", None)
         self.parent_srv._set_auth(site_id, user_id, auth_token)
-        logger.info("Signed into {0} as user with id {1}".format(self.parent_srv.server_address, user_id))
+        logger.info(f"Signed into {self.parent_srv.server_address} as user with id {user_id}")
         return Auth.contextmgr(self.sign_out)
 
     @api(version="3.10")
     def revoke_all_server_admin_tokens(self) -> None:
-        url = "{0}/{1}".format(self.baseurl, "revokeAllServerAdminTokens")
+        """
+        Revokes all personal access tokens for all server admins on the server.
+        """
+        url = f"{self.baseurl}/revokeAllServerAdminTokens"
         self.post_request(url, "")
         logger.info("Revoked all tokens for all server admins")

tableauserverclient/server/endpoint/custom_views_endpoint.py

@@ -1,10 +1,23 @@
+import io
 import logging
-from typing import List, Optional, Tuple
-
-from .endpoint import QuerysetEndpoint, api
-from .exceptions import MissingRequiredFieldError
+import os
+from contextlib import closing
+from pathlib import Path
+from typing import Optional, Union
+from collections.abc import Iterator
+
+from tableauserverclient.config import BYTES_PER_MB, config
+from tableauserverclient.filesys_helpers import get_file_object_size
+from tableauserverclient.server.endpoint.endpoint import QuerysetEndpoint, api
+from tableauserverclient.server.endpoint.exceptions import MissingRequiredFieldError
 from tableauserverclient.models import CustomViewItem, PaginationItem
-from tableauserverclient.server import RequestFactory, RequestOptions, ImageRequestOptions
+from tableauserverclient.server import (
+    RequestFactory,
+    RequestOptions,
+    ImageRequestOptions,
+    PDFRequestOptions,
+    CSVRequestOptions,
+)
 
 from tableauserverclient.helpers.logging import logger
 
@@ -16,14 +29,27 @@ Delete a custom view
 update the name or owner of a custom view.
 """
 
+FilePath = Union[str, os.PathLike]
+FileObject = Union[io.BufferedReader, io.BytesIO]
+FileObjectR = Union[io.BufferedReader, io.BytesIO]
+FileObjectW = Union[io.BufferedWriter, io.BytesIO]
+PathOrFileR = Union[FilePath, FileObjectR]
+PathOrFileW = Union[FilePath, FileObjectW]
+io_types_r = (io.BufferedReader, io.BytesIO)
+io_types_w = (io.BufferedWriter, io.BytesIO)
+
 
 class CustomViews(QuerysetEndpoint[CustomViewItem]):
     def __init__(self, parent_srv):
-        super(CustomViews, self).__init__(parent_srv)
+        super().__init__(parent_srv)
 
     @property
     def baseurl(self) -> str:
-        return "{0}/sites/{1}/customviews".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/customviews"
+
+    @property
+    def expurl(self) -> str:
+        return f"{self.parent_srv._server_address}/api/exp/sites/{self.parent_srv.site_id}/customviews"
 
     """
     If the request has no filter parameters: Administrators will see all custom views. 
@@ -37,7 +63,7 @@ class CustomViews(QuerysetEndpoint[CustomViewItem]):
     """
 
     @api(version="3.18")
-    def get(self, req_options: Optional["RequestOptions"] = None) -> Tuple[List[CustomViewItem], PaginationItem]:
+    def get(self, req_options: Optional["RequestOptions"] = None) -> tuple[list[CustomViewItem], PaginationItem]:
         logger.info("Querying all custom views on site")
         url = self.baseurl
         server_response = self.get_request(url, req_options)
@@ -50,8 +76,8 @@ class CustomViews(QuerysetEndpoint[CustomViewItem]):
         if not view_id:
             error = "Custom view item missing ID."
             raise MissingRequiredFieldError(error)
-        logger.info("Querying custom view (ID: {0})".format(view_id))
-        url = "{0}/{1}".format(self.baseurl, view_id)
+        logger.info(f"Querying custom view (ID: {view_id})")
+        url = f"{self.baseurl}/{view_id}"
         server_response = self.get_request(url)
         return CustomViewItem.from_response(server_response.content, self.parent_srv.namespace)
 
@@ -65,17 +91,53 @@ class CustomViews(QuerysetEndpoint[CustomViewItem]):
             return self._get_view_image(view_item, req_options)
 
         view_item._set_image(image_fetcher)
-        logger.info("Populated image for custom view (ID: {0})".format(view_item.id))
+        logger.info(f"Populated image for custom view (ID: {view_item.id})")
 
     def _get_view_image(self, view_item: CustomViewItem, req_options: Optional["ImageRequestOptions"]) -> bytes:
-        url = "{0}/{1}/image".format(self.baseurl, view_item.id)
+        url = f"{self.baseurl}/{view_item.id}/image"
         server_response = self.get_request(url, req_options)
         image = server_response.content
         return image
 
-    """
-    Not yet implemented: pdf or csv exports
-    """
+    @api(version="3.23")
+    def populate_pdf(self, custom_view_item: CustomViewItem, req_options: Optional["PDFRequestOptions"] = None) -> None:
+        if not custom_view_item.id:
+            error = "Custom View item missing ID."
+            raise MissingRequiredFieldError(error)
+
+        def pdf_fetcher():
+            return self._get_custom_view_pdf(custom_view_item, req_options)
+
+        custom_view_item._set_pdf(pdf_fetcher)
+        logger.info(f"Populated pdf for custom view (ID: {custom_view_item.id})")
+
+    def _get_custom_view_pdf(
+        self, custom_view_item: CustomViewItem, req_options: Optional["PDFRequestOptions"]
+    ) -> bytes:
+        url = f"{self.baseurl}/{custom_view_item.id}/pdf"
+        server_response = self.get_request(url, req_options)
+        pdf = server_response.content
+        return pdf
+
+    @api(version="3.23")
+    def populate_csv(self, custom_view_item: CustomViewItem, req_options: Optional["CSVRequestOptions"] = None) -> None:
+        if not custom_view_item.id:
+            error = "Custom View item missing ID."
+            raise MissingRequiredFieldError(error)
+
+        def csv_fetcher():
+            return self._get_custom_view_csv(custom_view_item, req_options)
+
+        custom_view_item._set_csv(csv_fetcher)
+        logger.info(f"Populated csv for custom view (ID: {custom_view_item.id})")
+
+    def _get_custom_view_csv(
+        self, custom_view_item: CustomViewItem, req_options: Optional["CSVRequestOptions"]
+    ) -> Iterator[bytes]:
+        url = f"{self.baseurl}/{custom_view_item.id}/data"
+
+        with closing(self.get_request(url, request_object=req_options, parameters={"stream": True})) as server_response:
+            yield from server_response.iter_content(1024)
 
     @api(version="3.18")
     def update(self, view_item: CustomViewItem) -> Optional[CustomViewItem]:
@@ -87,10 +149,10 @@ class CustomViews(QuerysetEndpoint[CustomViewItem]):
             return view_item
 
         # Update the custom view owner or name
-        url = "{0}/{1}".format(self.baseurl, view_item.id)
+        url = f"{self.baseurl}/{view_item.id}"
         update_req = RequestFactory.CustomView.update_req(view_item)
         server_response = self.put_request(url, update_req)
-        logger.info("Updated custom view (ID: {0})".format(view_item.id))
+        logger.info(f"Updated custom view (ID: {view_item.id})")
         return CustomViewItem.from_response(server_response.content, self.parent_srv.namespace)
 
     # Delete 1 view by id
@@ -99,6 +161,49 @@ class CustomViews(QuerysetEndpoint[CustomViewItem]):
         if not view_id:
             error = "Custom View ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}".format(self.baseurl, view_id)
+        url = f"{self.baseurl}/{view_id}"
         self.delete_request(url)
-        logger.info("Deleted single custom view (ID: {0})".format(view_id))
+        logger.info(f"Deleted single custom view (ID: {view_id})")
+
+    @api(version="3.21")
+    def download(self, view_item: CustomViewItem, file: PathOrFileW) -> PathOrFileW:
+        url = f"{self.expurl}/{view_item.id}/content"
+        server_response = self.get_request(url)
+        if isinstance(file, io_types_w):
+            file.write(server_response.content)
+            return file
+
+        with open(file, "wb") as f:
+            f.write(server_response.content)
+
+        return file
+
+    @api(version="3.21")
+    def publish(self, view_item: CustomViewItem, file: PathOrFileR) -> Optional[CustomViewItem]:
+        url = self.expurl
+        if isinstance(file, io_types_r):
+            size = get_file_object_size(file)
+        elif isinstance(file, (str, Path)) and (p := Path(file)).is_file():
+            size = p.stat().st_size
+        else:
+            raise ValueError("File path or file object required for publishing custom view.")
+
+        if size >= config.FILESIZE_LIMIT_MB * BYTES_PER_MB:
+            upload_session_id = self.parent_srv.fileuploads.upload(file)
+            url = f"{url}?uploadSessionId={upload_session_id}"
+            xml_request, content_type = RequestFactory.CustomView.publish_req_chunked(view_item)
+        else:
+            if isinstance(file, io_types_r):
+                file.seek(0)
+                contents = file.read()
+                if view_item.name is None:
+                    raise MissingRequiredFieldError("Custom view item missing name.")
+                filename = view_item.name
+            elif isinstance(file, (str, Path)):
+                filename = Path(file).name
+                contents = Path(file).read_bytes()
+
+            xml_request, content_type = RequestFactory.CustomView.publish_req(view_item, filename, contents)
+
+        server_response = self.post_request(url, xml_request, content_type)
+        return CustomViewItem.from_response(server_response.content, self.parent_srv.namespace)

tableauserverclient/server/endpoint/data_acceleration_report_endpoint.py

@@ -10,14 +10,14 @@ from tableauserverclient.helpers.logging import logger
 
 class DataAccelerationReport(Endpoint):
     def __init__(self, parent_srv):
-        super(DataAccelerationReport, self).__init__(parent_srv)
+        super().__init__(parent_srv)
 
         self._permissions = _PermissionsEndpoint(parent_srv, lambda: self.baseurl)
         self._default_permissions = _DefaultPermissionsEndpoint(parent_srv, lambda: self.baseurl)
 
     @property
     def baseurl(self):
-        return "{0}/sites/{1}/dataAccelerationReport".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/dataAccelerationReport"
 
     @api(version="3.8")
     def get(self, req_options=None):

tableauserverclient/server/endpoint/data_alert_endpoint.py

@@ -7,7 +7,7 @@ from tableauserverclient.models import DataAlertItem, PaginationItem, UserItem
 
 from tableauserverclient.helpers.logging import logger
 
-from typing import List, Optional, TYPE_CHECKING, Tuple, Union
+from typing import Optional, TYPE_CHECKING, Union
 
 
 if TYPE_CHECKING:
@@ -17,14 +17,14 @@ if TYPE_CHECKING:
 
 class DataAlerts(Endpoint):
     def __init__(self, parent_srv: "Server") -> None:
-        super(DataAlerts, self).__init__(parent_srv)
+        super().__init__(parent_srv)
 
     @property
     def baseurl(self) -> str:
-        return "{0}/sites/{1}/dataAlerts".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/dataAlerts"
 
     @api(version="3.2")
-    def get(self, req_options: Optional["RequestOptions"] = None) -> Tuple[List[DataAlertItem], PaginationItem]:
+    def get(self, req_options: Optional["RequestOptions"] = None) -> tuple[list[DataAlertItem], PaginationItem]:
         logger.info("Querying all dataAlerts on site")
         url = self.baseurl
         server_response = self.get_request(url, req_options)
@@ -38,8 +38,8 @@ class DataAlerts(Endpoint):
         if not dataAlert_id:
             error = "dataAlert ID undefined."
             raise ValueError(error)
-        logger.info("Querying single dataAlert (ID: {0})".format(dataAlert_id))
-        url = "{0}/{1}".format(self.baseurl, dataAlert_id)
+        logger.info(f"Querying single dataAlert (ID: {dataAlert_id})")
+        url = f"{self.baseurl}/{dataAlert_id}"
         server_response = self.get_request(url)
         return DataAlertItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
@@ -55,9 +55,9 @@ class DataAlerts(Endpoint):
             error = "Dataalert ID undefined."
             raise ValueError(error)
         # DELETE /api/api-version/sites/site-id/dataAlerts/data-alert-id/users/user-id
-        url = "{0}/{1}".format(self.baseurl, dataAlert_id)
+        url = f"{self.baseurl}/{dataAlert_id}"
         self.delete_request(url)
-        logger.info("Deleted single dataAlert (ID: {0})".format(dataAlert_id))
+        logger.info(f"Deleted single dataAlert (ID: {dataAlert_id})")
 
     @api(version="3.2")
     def delete_user_from_alert(self, dataAlert: Union[DataAlertItem, str], user: Union[UserItem, str]) -> None:
@@ -80,9 +80,9 @@ class DataAlerts(Endpoint):
             error = "User ID undefined."
             raise ValueError(error)
         # DELETE /api/api-version/sites/site-id/dataAlerts/data-alert-id/users/user-id
-        url = "{0}/{1}/users/{2}".format(self.baseurl, dataAlert_id, user_id)
+        url = f"{self.baseurl}/{dataAlert_id}/users/{user_id}"
         self.delete_request(url)
-        logger.info("Deleted User (ID {0}) from dataAlert (ID: {1})".format(user_id, dataAlert_id))
+        logger.info(f"Deleted User (ID {user_id}) from dataAlert (ID: {dataAlert_id})")
 
     @api(version="3.2")
     def add_user_to_alert(self, dataAlert_item: DataAlertItem, user: Union[UserItem, str]) -> UserItem:
@@ -98,10 +98,10 @@ class DataAlerts(Endpoint):
         if not user_id:
             error = "User ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}/users".format(self.baseurl, dataAlert_item.id)
+        url = f"{self.baseurl}/{dataAlert_item.id}/users"
         update_req = RequestFactory.DataAlert.add_user_to_alert(dataAlert_item, user_id)
         server_response = self.post_request(url, update_req)
-        logger.info("Added user (ID {0}) to dataAlert item (ID: {1})".format(user_id, dataAlert_item.id))
+        logger.info(f"Added user (ID {user_id}) to dataAlert item (ID: {dataAlert_item.id})")
         added_user = UserItem.from_response(server_response.content, self.parent_srv.namespace)[0]
         return added_user
 
@@ -111,9 +111,9 @@ class DataAlerts(Endpoint):
             error = "Dataalert item missing ID."
             raise MissingRequiredFieldError(error)
 
-        url = "{0}/{1}".format(self.baseurl, dataAlert_item.id)
+        url = f"{self.baseurl}/{dataAlert_item.id}"
         update_req = RequestFactory.DataAlert.update_req(dataAlert_item)
         server_response = self.put_request(url, update_req)
-        logger.info("Updated dataAlert item (ID: {0})".format(dataAlert_item.id))
+        logger.info(f"Updated dataAlert item (ID: {dataAlert_item.id})")
         updated_dataAlert = DataAlertItem.from_response(server_response.content, self.parent_srv.namespace)[0]
         return updated_dataAlert

tableauserverclient/server/endpoint/databases_endpoint.py

@@ -1,19 +1,22 @@
 import logging
-
-from .default_permissions_endpoint import _DefaultPermissionsEndpoint
-from .dqw_endpoint import _DataQualityWarningEndpoint
-from .endpoint import api, Endpoint
-from .exceptions import MissingRequiredFieldError
-from .permissions_endpoint import _PermissionsEndpoint
+from typing import Union
+from collections.abc import Iterable
+
+from tableauserverclient.server.endpoint.default_permissions_endpoint import _DefaultPermissionsEndpoint
+from tableauserverclient.server.endpoint.dqw_endpoint import _DataQualityWarningEndpoint
+from tableauserverclient.server.endpoint.endpoint import api, Endpoint
+from tableauserverclient.server.endpoint.exceptions import MissingRequiredFieldError
+from tableauserverclient.server.endpoint.permissions_endpoint import _PermissionsEndpoint
+from tableauserverclient.server.endpoint.resource_tagger import TaggingMixin
 from tableauserverclient.server import RequestFactory
 from tableauserverclient.models import DatabaseItem, TableItem, PaginationItem, Resource
 
 from tableauserverclient.helpers.logging import logger
 
 
-class Databases(Endpoint):
+class Databases(Endpoint, TaggingMixin):
     def __init__(self, parent_srv):
-        super(Databases, self).__init__(parent_srv)
+        super().__init__(parent_srv)
 
         self._permissions = _PermissionsEndpoint(parent_srv, lambda: self.baseurl)
         self._default_permissions = _DefaultPermissionsEndpoint(parent_srv, lambda: self.baseurl)
@@ -21,7 +24,7 @@ class Databases(Endpoint):
 
     @property
     def baseurl(self):
-        return "{0}/sites/{1}/databases".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/databases"
 
     @api(version="3.5")
     def get(self, req_options=None):
@@ -38,8 +41,8 @@ class Databases(Endpoint):
         if not database_id:
             error = "database ID undefined."
             raise ValueError(error)
-        logger.info("Querying single database (ID: {0})".format(database_id))
-        url = "{0}/{1}".format(self.baseurl, database_id)
+        logger.info(f"Querying single database (ID: {database_id})")
+        url = f"{self.baseurl}/{database_id}"
         server_response = self.get_request(url)
         return DatabaseItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
@@ -48,9 +51,9 @@ class Databases(Endpoint):
         if not database_id:
             error = "Database ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}".format(self.baseurl, database_id)
+        url = f"{self.baseurl}/{database_id}"
         self.delete_request(url)
-        logger.info("Deleted single database (ID: {0})".format(database_id))
+        logger.info(f"Deleted single database (ID: {database_id})")
 
     @api(version="3.5")
     def update(self, database_item):
@@ -58,10 +61,10 @@ class Databases(Endpoint):
             error = "Database item missing ID."
             raise MissingRequiredFieldError(error)
 
-        url = "{0}/{1}".format(self.baseurl, database_item.id)
+        url = f"{self.baseurl}/{database_item.id}"
         update_req = RequestFactory.Database.update_req(database_item)
         server_response = self.put_request(url, update_req)
-        logger.info("Updated database item (ID: {0})".format(database_item.id))
+        logger.info(f"Updated database item (ID: {database_item.id})")
         updated_database = DatabaseItem.from_response(server_response.content, self.parent_srv.namespace)[0]
         return updated_database
 
@@ -76,10 +79,10 @@ class Databases(Endpoint):
             return self._get_tables_for_database(database_item)
 
         database_item._set_tables(column_fetcher)
-        logger.info("Populated tables for database (ID: {0}".format(database_item.id))
+        logger.info(f"Populated tables for database (ID: {database_item.id}")
 
     def _get_tables_for_database(self, database_item):
-        url = "{0}/{1}/tables".format(self.baseurl, database_item.id)
+        url = f"{self.baseurl}/{database_item.id}/tables"
         server_response = self.get_request(url)
         tables = TableItem.from_response(server_response.content, self.parent_srv.namespace)
         return tables
@@ -123,3 +126,15 @@ class Databases(Endpoint):
     @api(version="3.5")
     def delete_dqw(self, item):
         self._data_quality_warnings.clear(item)
+
+    @api(version="3.9")
+    def add_tags(self, item: Union[DatabaseItem, str], tags: Iterable[str]) -> set[str]:
+        return super().add_tags(item, tags)
+
+    @api(version="3.9")
+    def delete_tags(self, item: Union[DatabaseItem, str], tags: Iterable[str]) -> None:
+        super().delete_tags(item, tags)
+
+    @api(version="3.9")
+    def update_tags(self, item: DatabaseItem) -> None:
+        raise NotImplementedError("Update tags is not supported for databases.")