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

tableauserverclient/server/endpoint/views_endpoint.py

@@ -1,18 +1,21 @@
 import logging
 from contextlib import closing
 
-from .endpoint import QuerysetEndpoint, api
-from .exceptions import MissingRequiredFieldError
-from .permissions_endpoint import _PermissionsEndpoint
-from .resource_tagger import _ResourceTagger
+from tableauserverclient.server.endpoint.endpoint import QuerysetEndpoint, api
+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.query import QuerySet
+
 from tableauserverclient.models import ViewItem, PaginationItem
 
 from tableauserverclient.helpers.logging import logger
 
-from typing import Iterator, List, Optional, Tuple, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING, Union
+from collections.abc import Iterable, Iterator
 
 if TYPE_CHECKING:
-    from ..request_options import (
+    from tableauserverclient.server.request_options import (
         RequestOptions,
         CSVRequestOptions,
         PDFRequestOptions,
@@ -21,25 +24,24 @@ if TYPE_CHECKING:
     )
 
 
-class Views(QuerysetEndpoint[ViewItem]):
+class Views(QuerysetEndpoint[ViewItem], TaggingMixin[ViewItem]):
     def __init__(self, parent_srv):
-        super(Views, self).__init__(parent_srv)
-        self._resource_tagger = _ResourceTagger(parent_srv)
+        super().__init__(parent_srv)
         self._permissions = _PermissionsEndpoint(parent_srv, lambda: self.baseurl)
 
     # Used because populate_preview_image functionaliy requires workbook endpoint
     @property
     def siteurl(self) -> str:
-        return "{0}/sites/{1}".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}"
 
     @property
     def baseurl(self) -> str:
-        return "{0}/views".format(self.siteurl)
+        return f"{self.siteurl}/views"
 
     @api(version="2.2")
     def get(
         self, req_options: Optional["RequestOptions"] = None, usage: bool = False
-    ) -> Tuple[List[ViewItem], PaginationItem]:
+    ) -> tuple[list[ViewItem], PaginationItem]:
         logger.info("Querying all views on site")
         url = self.baseurl
         if usage:
@@ -54,8 +56,8 @@ class Views(QuerysetEndpoint[ViewItem]):
         if not view_id:
             error = "View item missing ID."
             raise MissingRequiredFieldError(error)
-        logger.info("Querying single view (ID: {0})".format(view_id))
-        url = "{0}/{1}".format(self.baseurl, view_id)
+        logger.info(f"Querying single view (ID: {view_id})")
+        url = f"{self.baseurl}/{view_id}"
         if usage:
             url += "?includeUsageStatistics=true"
         server_response = self.get_request(url)
@@ -71,10 +73,10 @@ class Views(QuerysetEndpoint[ViewItem]):
             return self._get_preview_for_view(view_item)
 
         view_item._set_preview_image(image_fetcher)
-        logger.info("Populated preview image for view (ID: {0})".format(view_item.id))
+        logger.info(f"Populated preview image for view (ID: {view_item.id})")
 
     def _get_preview_for_view(self, view_item: ViewItem) -> bytes:
-        url = "{0}/workbooks/{1}/views/{2}/previewImage".format(self.siteurl, view_item.workbook_id, view_item.id)
+        url = f"{self.siteurl}/workbooks/{view_item.workbook_id}/views/{view_item.id}/previewImage"
         server_response = self.get_request(url)
         image = server_response.content
         return image
@@ -89,10 +91,10 @@ class Views(QuerysetEndpoint[ViewItem]):
             return self._get_view_image(view_item, req_options)
 
         view_item._set_image(image_fetcher)
-        logger.info("Populated image for view (ID: {0})".format(view_item.id))
+        logger.info(f"Populated image for view (ID: {view_item.id})")
 
     def _get_view_image(self, view_item: ViewItem, 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
@@ -107,10 +109,10 @@ class Views(QuerysetEndpoint[ViewItem]):
             return self._get_view_pdf(view_item, req_options)
 
         view_item._set_pdf(pdf_fetcher)
-        logger.info("Populated pdf for view (ID: {0})".format(view_item.id))
+        logger.info(f"Populated pdf for view (ID: {view_item.id})")
 
     def _get_view_pdf(self, view_item: ViewItem, req_options: Optional["PDFRequestOptions"]) -> bytes:
-        url = "{0}/{1}/pdf".format(self.baseurl, view_item.id)
+        url = f"{self.baseurl}/{view_item.id}/pdf"
         server_response = self.get_request(url, req_options)
         pdf = server_response.content
         return pdf
@@ -125,10 +127,10 @@ class Views(QuerysetEndpoint[ViewItem]):
             return self._get_view_csv(view_item, req_options)
 
         view_item._set_csv(csv_fetcher)
-        logger.info("Populated csv for view (ID: {0})".format(view_item.id))
+        logger.info(f"Populated csv for view (ID: {view_item.id})")
 
     def _get_view_csv(self, view_item: ViewItem, req_options: Optional["CSVRequestOptions"]) -> Iterator[bytes]:
-        url = "{0}/{1}/data".format(self.baseurl, view_item.id)
+        url = f"{self.baseurl}/{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)
@@ -143,10 +145,10 @@ class Views(QuerysetEndpoint[ViewItem]):
             return self._get_view_excel(view_item, req_options)
 
         view_item._set_excel(excel_fetcher)
-        logger.info("Populated excel for view (ID: {0})".format(view_item.id))
+        logger.info(f"Populated excel for view (ID: {view_item.id})")
 
     def _get_view_excel(self, view_item: ViewItem, req_options: Optional["ExcelRequestOptions"]) -> Iterator[bytes]:
-        url = "{0}/{1}/crosstab/excel".format(self.baseurl, view_item.id)
+        url = f"{self.baseurl}/{view_item.id}/crosstab/excel"
 
         with closing(self.get_request(url, request_object=req_options, parameters={"stream": True})) as server_response:
             yield from server_response.iter_content(1024)
@@ -169,7 +171,91 @@ class Views(QuerysetEndpoint[ViewItem]):
             error = "View item missing ID. View must be retrieved from server first."
             raise MissingRequiredFieldError(error)
 
-        self._resource_tagger.update_tags(self.baseurl, view_item)
+        self.update_tags(view_item)
 
         # Returning view item to stay consistent with datasource/view update functions
         return view_item
+
+    @api(version="1.0")
+    def add_tags(self, item: Union[ViewItem, str], tags: Union[Iterable[str], str]) -> set[str]:
+        return super().add_tags(item, tags)
+
+    @api(version="1.0")
+    def delete_tags(self, item: Union[ViewItem, str], tags: Union[Iterable[str], str]) -> None:
+        return super().delete_tags(item, tags)
+
+    @api(version="1.0")
+    def update_tags(self, item: ViewItem) -> None:
+        return super().update_tags(item)
+
+    def filter(self, *invalid, page_size: Optional[int] = None, **kwargs) -> QuerySet[ViewItem]:
+        """
+        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:
+
+
+        caption=...
+        caption__in=...
+        content_url=...
+        content_url__in=...
+        created_at=...
+        created_at__gt=...
+        created_at__gte=...
+        created_at__lt=...
+        created_at__lte=...
+        favorites_total=...
+        favorites_total__gt=...
+        favorites_total__gte=...
+        favorites_total__lt=...
+        favorites_total__lte=...
+        fields=...
+        fields__in=...
+        hits_total=...
+        hits_total__gt=...
+        hits_total__gte=...
+        hits_total__lt=...
+        hits_total__lte=...
+        name=...
+        name__in=...
+        owner_domain=...
+        owner_domain__in=...
+        owner_email=...
+        owner_email__in=...
+        owner_name=...
+        project_name=...
+        project_name__in=...
+        sheet_number=...
+        sheet_number__gt=...
+        sheet_number__gte=...
+        sheet_number__lt=...
+        sheet_number__lte=...
+        sheet_type=...
+        sheet_type__in=...
+        tags=...
+        tags__in=...
+        title=...
+        title__in=...
+        updated_at=...
+        updated_at__gt=...
+        updated_at__gte=...
+        updated_at__lt=...
+        updated_at__lte=...
+        view_url_name=...
+        view_url_name__in=...
+        workbook_description=...
+        workbook_description__in=...
+        workbook_name=...
+        workbook_name__in=...
+        """
+
+        return super().filter(*invalid, page_size=page_size, **kwargs)

tableauserverclient/server/endpoint/virtual_connections_endpoint.py

@@ -0,0 +1,174 @@
+from functools import partial
+import json
+from pathlib import Path
+from typing import Optional, TYPE_CHECKING, Union
+from collections.abc import Iterable
+
+from tableauserverclient.models.connection_item import ConnectionItem
+from tableauserverclient.models.pagination_item import PaginationItem
+from tableauserverclient.models.revision_item import RevisionItem
+from tableauserverclient.models.virtual_connection_item import VirtualConnectionItem
+from tableauserverclient.server.request_factory import RequestFactory
+from tableauserverclient.server.request_options import RequestOptions
+from tableauserverclient.server.endpoint.endpoint import QuerysetEndpoint, api
+from tableauserverclient.server.endpoint.permissions_endpoint import _PermissionsEndpoint
+from tableauserverclient.server.endpoint.resource_tagger import TaggingMixin
+from tableauserverclient.server.pager import Pager
+
+if TYPE_CHECKING:
+    from tableauserverclient.server import Server
+
+
+class VirtualConnections(QuerysetEndpoint[VirtualConnectionItem], TaggingMixin):
+    def __init__(self, parent_srv: "Server") -> None:
+        super().__init__(parent_srv)
+        self._permissions = _PermissionsEndpoint(parent_srv, lambda: self.baseurl)
+
+    @property
+    def baseurl(self) -> str:
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/virtualConnections"
+
+    @api(version="3.18")
+    def get(self, req_options: Optional[RequestOptions] = None) -> tuple[list[VirtualConnectionItem], PaginationItem]:
+        server_response = self.get_request(self.baseurl, req_options)
+        pagination_item = PaginationItem.from_response(server_response.content, self.parent_srv.namespace)
+        virtual_connections = VirtualConnectionItem.from_response(server_response.content, self.parent_srv.namespace)
+        return virtual_connections, pagination_item
+
+    @api(version="3.18")
+    def populate_connections(self, virtual_connection: VirtualConnectionItem) -> VirtualConnectionItem:
+        def _connection_fetcher():
+            return Pager(partial(self._get_virtual_database_connections, virtual_connection))
+
+        virtual_connection._connections = _connection_fetcher
+        return virtual_connection
+
+    def _get_virtual_database_connections(
+        self, virtual_connection: VirtualConnectionItem, req_options: Optional[RequestOptions] = None
+    ) -> tuple[list[ConnectionItem], PaginationItem]:
+        server_response = self.get_request(f"{self.baseurl}/{virtual_connection.id}/connections", req_options)
+        connections = ConnectionItem.from_response(server_response.content, self.parent_srv.namespace)
+        pagination_item = PaginationItem.from_response(server_response.content, self.parent_srv.namespace)
+
+        return connections, pagination_item
+
+    @api(version="3.18")
+    def update_connection_db_connection(
+        self, virtual_connection: Union[str, VirtualConnectionItem], connection: ConnectionItem
+    ) -> ConnectionItem:
+        vconn_id = getattr(virtual_connection, "id", virtual_connection)
+        url = f"{self.baseurl}/{vconn_id}/connections/{connection.id}/modify"
+        xml_request = RequestFactory.VirtualConnection.update_db_connection(connection)
+        server_response = self.put_request(url, xml_request)
+        return ConnectionItem.from_response(server_response.content, self.parent_srv.namespace)[0]
+
+    @api(version="3.23")
+    def get_by_id(self, virtual_connection: Union[str, VirtualConnectionItem]) -> VirtualConnectionItem:
+        vconn_id = getattr(virtual_connection, "id", virtual_connection)
+        url = f"{self.baseurl}/{vconn_id}"
+        server_response = self.get_request(url)
+        return VirtualConnectionItem.from_response(server_response.content, self.parent_srv.namespace)[0]
+
+    @api(version="3.23")
+    def download(self, virtual_connection: Union[str, VirtualConnectionItem]) -> str:
+        v_conn = self.get_by_id(virtual_connection)
+        return json.dumps(v_conn.content)
+
+    @api(version="3.23")
+    def update(self, virtual_connection: VirtualConnectionItem) -> VirtualConnectionItem:
+        url = f"{self.baseurl}/{virtual_connection.id}"
+        xml_request = RequestFactory.VirtualConnection.update(virtual_connection)
+        server_response = self.put_request(url, xml_request)
+        return VirtualConnectionItem.from_response(server_response.content, self.parent_srv.namespace)[0]
+
+    @api(version="3.23")
+    def get_revisions(
+        self, virtual_connection: VirtualConnectionItem, req_options: Optional[RequestOptions] = None
+    ) -> tuple[list[RevisionItem], PaginationItem]:
+        server_response = self.get_request(f"{self.baseurl}/{virtual_connection.id}/revisions", req_options)
+        pagination_item = PaginationItem.from_response(server_response.content, self.parent_srv.namespace)
+        revisions = RevisionItem.from_response(server_response.content, self.parent_srv.namespace, virtual_connection)
+        return revisions, pagination_item
+
+    @api(version="3.23")
+    def download_revision(self, virtual_connection: VirtualConnectionItem, revision_number: int) -> str:
+        url = f"{self.baseurl}/{virtual_connection.id}/revisions/{revision_number}"
+        server_response = self.get_request(url)
+        virtual_connection = VirtualConnectionItem.from_response(server_response.content, self.parent_srv.namespace)[0]
+        return json.dumps(virtual_connection.content)
+
+    @api(version="3.23")
+    def delete(self, virtual_connection: Union[VirtualConnectionItem, str]) -> None:
+        vconn_id = getattr(virtual_connection, "id", virtual_connection)
+        self.delete_request(f"{self.baseurl}/{vconn_id}")
+
+    @api(version="3.23")
+    def publish(
+        self,
+        virtual_connection: VirtualConnectionItem,
+        virtual_connection_content: str,
+        mode: str = "CreateNew",
+        publish_as_draft: bool = False,
+    ) -> VirtualConnectionItem:
+        """
+        Publish a virtual connection to the server.
+
+        For the virtual_connection object, name, project_id, and owner_id are
+        required.
+
+        The virtual_connection_content can be a json string or a file path to a
+        json file.
+
+        The mode can be "CreateNew" or "Overwrite". If mode is
+        "Overwrite" and the virtual connection already exists, it will be
+        overwritten.
+
+        If publish_as_draft is True, the virtual connection will be published
+        as a draft, and the id of the draft will be on the response object.
+        """
+        try:
+            json.loads(virtual_connection_content)
+        except json.JSONDecodeError:
+            file = Path(virtual_connection_content)
+            if not file.exists():
+                raise RuntimeError(f"{virtual_connection_content} is not valid json nor an existing file path")
+            content = file.read_text()
+        else:
+            content = virtual_connection_content
+
+        if mode not in ["CreateNew", "Overwrite"]:
+            raise ValueError(f"Invalid mode: {mode}")
+        overwrite = mode == "Overwrite"
+
+        url = f"{self.baseurl}?overwrite={str(overwrite).lower()}&publishAsDraft={str(publish_as_draft).lower()}"
+        xml_request = RequestFactory.VirtualConnection.publish(virtual_connection, content)
+        server_response = self.post_request(url, xml_request)
+        return VirtualConnectionItem.from_response(server_response.content, self.parent_srv.namespace)[0]
+
+    @api(version="3.22")
+    def populate_permissions(self, item: VirtualConnectionItem) -> None:
+        self._permissions.populate(item)
+
+    @api(version="3.22")
+    def add_permissions(self, resource, rules):
+        return self._permissions.update(resource, rules)
+
+    @api(version="3.22")
+    def delete_permission(self, item, capability_item):
+        return self._permissions.delete(item, capability_item)
+
+    @api(version="3.23")
+    def add_tags(
+        self, virtual_connection: Union[VirtualConnectionItem, str], tags: Union[Iterable[str], str]
+    ) -> set[str]:
+        return super().add_tags(virtual_connection, tags)
+
+    @api(version="3.23")
+    def delete_tags(
+        self, virtual_connection: Union[VirtualConnectionItem, str], tags: Union[Iterable[str], str]
+    ) -> None:
+        return super().delete_tags(virtual_connection, tags)
+
+    @api(version="3.23")
+    def update_tags(self, virtual_connection: VirtualConnectionItem) -> None:
+        raise NotImplementedError("Update tags is not implemented for Virtual Connections")

tableauserverclient/server/endpoint/webhooks_endpoint.py

@@ -6,7 +6,7 @@ from tableauserverclient.models import WebhookItem, PaginationItem
 
 from tableauserverclient.helpers.logging import logger
 
-from typing import List, Optional, TYPE_CHECKING, Tuple
+from typing import Optional, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from ..server import Server
@@ -15,14 +15,14 @@ if TYPE_CHECKING:
 
 class Webhooks(Endpoint):
     def __init__(self, parent_srv: "Server") -> None:
-        super(Webhooks, self).__init__(parent_srv)
+        super().__init__(parent_srv)
 
     @property
     def baseurl(self) -> str:
-        return "{0}/sites/{1}/webhooks".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/webhooks"
 
     @api(version="3.6")
-    def get(self, req_options: Optional["RequestOptions"] = None) -> Tuple[List[WebhookItem], PaginationItem]:
+    def get(self, req_options: Optional["RequestOptions"] = None) -> tuple[list[WebhookItem], PaginationItem]:
         logger.info("Querying all Webhooks on site")
         url = self.baseurl
         server_response = self.get_request(url, req_options)
@@ -35,8 +35,8 @@ class Webhooks(Endpoint):
         if not webhook_id:
             error = "Webhook ID undefined."
             raise ValueError(error)
-        logger.info("Querying single webhook (ID: {0})".format(webhook_id))
-        url = "{0}/{1}".format(self.baseurl, webhook_id)
+        logger.info(f"Querying single webhook (ID: {webhook_id})")
+        url = f"{self.baseurl}/{webhook_id}"
         server_response = self.get_request(url)
         return WebhookItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
@@ -45,9 +45,9 @@ class Webhooks(Endpoint):
         if not webhook_id:
             error = "Webhook ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}".format(self.baseurl, webhook_id)
+        url = f"{self.baseurl}/{webhook_id}"
         self.delete_request(url)
-        logger.info("Deleted single webhook (ID: {0})".format(webhook_id))
+        logger.info(f"Deleted single webhook (ID: {webhook_id})")
 
     @api(version="3.6")
     def create(self, webhook_item: WebhookItem) -> WebhookItem:
@@ -56,7 +56,7 @@ class Webhooks(Endpoint):
         server_response = self.post_request(url, create_req)
         new_webhook = WebhookItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
-        logger.info("Created new webhook (ID: {0})".format(new_webhook.id))
+        logger.info(f"Created new webhook (ID: {new_webhook.id})")
         return new_webhook
 
     @api(version="3.6")
@@ -64,7 +64,7 @@ class Webhooks(Endpoint):
         if not webhook_id:
             error = "Webhook ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}/test".format(self.baseurl, webhook_id)
+        url = f"{self.baseurl}/{webhook_id}/test"
         testOutcome = self.get_request(url)
-        logger.info("Testing webhook (ID: {0} returned {1})".format(webhook_id, testOutcome))
+        logger.info(f"Testing webhook (ID: {webhook_id} returned {testOutcome})")
         return testOutcome