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

tableauserverclient/server/endpoint/projects_endpoint.py

@@ -5,9 +5,10 @@ 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 import RequestFactory, RequestOptions
+from tableauserverclient.models.permissions_item import PermissionsRule
 from tableauserverclient.models import ProjectItem, PaginationItem, Resource
 
-from typing import List, Optional, Tuple, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING
 
 from tableauserverclient.server.query import QuerySet
 
@@ -20,17 +21,17 @@ from tableauserverclient.helpers.logging import logger
 
 class Projects(QuerysetEndpoint[ProjectItem]):
     def __init__(self, parent_srv: "Server") -> None:
-        super(Projects, 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) -> str:
-        return "{0}/sites/{1}/projects".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/projects"
 
     @api(version="2.0")
-    def get(self, req_options: Optional["RequestOptions"] = None) -> Tuple[List[ProjectItem], PaginationItem]:
+    def get(self, req_options: Optional["RequestOptions"] = None) -> tuple[list[ProjectItem], PaginationItem]:
         logger.info("Querying all projects on site")
         url = self.baseurl
         server_response = self.get_request(url, req_options)
@@ -43,9 +44,9 @@ class Projects(QuerysetEndpoint[ProjectItem]):
         if not project_id:
             error = "Project ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}".format(self.baseurl, project_id)
+        url = f"{self.baseurl}/{project_id}"
         self.delete_request(url)
-        logger.info("Deleted single project (ID: {0})".format(project_id))
+        logger.info(f"Deleted single project (ID: {project_id})")
 
     @api(version="2.0")
     def update(self, project_item: ProjectItem, samples: bool = False) -> ProjectItem:
@@ -54,10 +55,10 @@ class Projects(QuerysetEndpoint[ProjectItem]):
             raise MissingRequiredFieldError(error)
 
         params = {"params": {RequestOptions.Field.PublishSamples: samples}}
-        url = "{0}/{1}".format(self.baseurl, project_item.id)
+        url = f"{self.baseurl}/{project_item.id}"
         update_req = RequestFactory.Project.update_req(project_item)
         server_response = self.put_request(url, update_req, XML_CONTENT_TYPE, params)
-        logger.info("Updated project item (ID: {0})".format(project_item.id))
+        logger.info(f"Updated project item (ID: {project_item.id})")
         updated_project = ProjectItem.from_response(server_response.content, self.parent_srv.namespace)[0]
         return updated_project
 
@@ -66,11 +67,11 @@ class Projects(QuerysetEndpoint[ProjectItem]):
         params = {"params": {RequestOptions.Field.PublishSamples: samples}}
         url = self.baseurl
         if project_item._samples:
-            url = "{0}?publishSamples={1}".format(self.baseurl, project_item._samples)
+            url = f"{self.baseurl}?publishSamples={project_item._samples}"
         create_req = RequestFactory.Project.create_req(project_item)
         server_response = self.post_request(url, create_req, XML_CONTENT_TYPE, params)
         new_project = ProjectItem.from_response(server_response.content, self.parent_srv.namespace)[0]
-        logger.info("Created new project (ID: {0})".format(new_project.id))
+        logger.info(f"Created new project (ID: {new_project.id})")
         return new_project
 
     @api(version="2.0")
@@ -78,85 +79,135 @@ class Projects(QuerysetEndpoint[ProjectItem]):
         self._permissions.populate(item)
 
     @api(version="2.0")
-    def update_permissions(self, item, rules):
+    def update_permissions(self, item: ProjectItem, rules: list[PermissionsRule]) -> list[PermissionsRule]:
         return self._permissions.update(item, rules)
 
     @api(version="2.0")
-    def delete_permission(self, item, rules):
+    def delete_permission(self, item: ProjectItem, rules: list[PermissionsRule]) -> None:
         self._permissions.delete(item, rules)
 
     @api(version="2.1")
-    def populate_workbook_default_permissions(self, item):
+    def populate_workbook_default_permissions(self, item: ProjectItem) -> None:
         self._default_permissions.populate_default_permissions(item, Resource.Workbook)
 
     @api(version="2.1")
-    def populate_datasource_default_permissions(self, item):
+    def populate_datasource_default_permissions(self, item: ProjectItem) -> None:
         self._default_permissions.populate_default_permissions(item, Resource.Datasource)
 
     @api(version="3.2")
-    def populate_metric_default_permissions(self, item):
+    def populate_metric_default_permissions(self, item: ProjectItem) -> None:
         self._default_permissions.populate_default_permissions(item, Resource.Metric)
 
     @api(version="3.4")
-    def populate_datarole_default_permissions(self, item):
+    def populate_datarole_default_permissions(self, item: ProjectItem) -> None:
         self._default_permissions.populate_default_permissions(item, Resource.Datarole)
 
     @api(version="3.4")
-    def populate_flow_default_permissions(self, item):
+    def populate_flow_default_permissions(self, item: ProjectItem) -> None:
         self._default_permissions.populate_default_permissions(item, Resource.Flow)
 
     @api(version="3.4")
-    def populate_lens_default_permissions(self, item):
+    def populate_lens_default_permissions(self, item: ProjectItem) -> None:
         self._default_permissions.populate_default_permissions(item, Resource.Lens)
 
+    @api(version="3.23")
+    def populate_virtualconnection_default_permissions(self, item: ProjectItem) -> None:
+        self._default_permissions.populate_default_permissions(item, Resource.VirtualConnection)
+
+    @api(version="3.23")
+    def populate_database_default_permissions(self, item: ProjectItem) -> None:
+        self._default_permissions.populate_default_permissions(item, Resource.Database)
+
+    @api(version="3.23")
+    def populate_table_default_permissions(self, item: ProjectItem) -> None:
+        self._default_permissions.populate_default_permissions(item, Resource.Table)
+
     @api(version="2.1")
-    def update_workbook_default_permissions(self, item, rules):
+    def update_workbook_default_permissions(
+        self, item: ProjectItem, rules: list[PermissionsRule]
+    ) -> list[PermissionsRule]:
         return self._default_permissions.update_default_permissions(item, rules, Resource.Workbook)
 
     @api(version="2.1")
-    def update_datasource_default_permissions(self, item, rules):
+    def update_datasource_default_permissions(
+        self, item: ProjectItem, rules: list[PermissionsRule]
+    ) -> list[PermissionsRule]:
         return self._default_permissions.update_default_permissions(item, rules, Resource.Datasource)
 
     @api(version="3.2")
-    def update_metric_default_permissions(self, item, rules):
+    def update_metric_default_permissions(
+        self, item: ProjectItem, rules: list[PermissionsRule]
+    ) -> list[PermissionsRule]:
         return self._default_permissions.update_default_permissions(item, rules, Resource.Metric)
 
     @api(version="3.4")
-    def update_datarole_default_permissions(self, item, rules):
+    def update_datarole_default_permissions(
+        self, item: ProjectItem, rules: list[PermissionsRule]
+    ) -> list[PermissionsRule]:
         return self._default_permissions.update_default_permissions(item, rules, Resource.Datarole)
 
     @api(version="3.4")
-    def update_flow_default_permissions(self, item, rules):
+    def update_flow_default_permissions(self, item: ProjectItem, rules: list[PermissionsRule]) -> list[PermissionsRule]:
         return self._default_permissions.update_default_permissions(item, rules, Resource.Flow)
 
     @api(version="3.4")
-    def update_lens_default_permissions(self, item, rules):
+    def update_lens_default_permissions(self, item: ProjectItem, rules: list[PermissionsRule]) -> list[PermissionsRule]:
         return self._default_permissions.update_default_permissions(item, rules, Resource.Lens)
 
+    @api(version="3.23")
+    def update_virtualconnection_default_permissions(
+        self, item: ProjectItem, rules: list[PermissionsRule]
+    ) -> list[PermissionsRule]:
+        return self._default_permissions.update_default_permissions(item, rules, Resource.VirtualConnection)
+
+    @api(version="3.23")
+    def update_database_default_permissions(
+        self, item: ProjectItem, rules: list[PermissionsRule]
+    ) -> list[PermissionsRule]:
+        return self._default_permissions.update_default_permissions(item, rules, Resource.Database)
+
+    @api(version="3.23")
+    def update_table_default_permissions(
+        self, item: ProjectItem, rules: list[PermissionsRule]
+    ) -> list[PermissionsRule]:
+        return self._default_permissions.update_default_permissions(item, rules, Resource.Table)
+
     @api(version="2.1")
-    def delete_workbook_default_permissions(self, item, rule):
+    def delete_workbook_default_permissions(self, item: ProjectItem, rule: PermissionsRule) -> None:
         self._default_permissions.delete_default_permission(item, rule, Resource.Workbook)
 
     @api(version="2.1")
-    def delete_datasource_default_permissions(self, item, rule):
+    def delete_datasource_default_permissions(self, item: ProjectItem, rule: PermissionsRule) -> None:
         self._default_permissions.delete_default_permission(item, rule, Resource.Datasource)
 
     @api(version="3.2")
-    def delete_metric_default_permissions(self, item, rule):
+    def delete_metric_default_permissions(self, item: ProjectItem, rule: PermissionsRule) -> None:
         self._default_permissions.delete_default_permission(item, rule, Resource.Metric)
 
     @api(version="3.4")
-    def delete_datarole_default_permissions(self, item, rule):
+    def delete_datarole_default_permissions(self, item: ProjectItem, rule: PermissionsRule) -> None:
         self._default_permissions.delete_default_permission(item, rule, Resource.Datarole)
 
     @api(version="3.4")
-    def delete_flow_default_permissions(self, item, rule):
+    def delete_flow_default_permissions(self, item: ProjectItem, rule: PermissionsRule) -> None:
         self._default_permissions.delete_default_permission(item, rule, Resource.Flow)
 
     @api(version="3.4")
-    def delete_lens_default_permissions(self, item, rule):
+    def delete_lens_default_permissions(self, item: ProjectItem, rule: PermissionsRule) -> None:
         self._default_permissions.delete_default_permission(item, rule, Resource.Lens)
 
+    @api(version="3.23")
+    def delete_virtualconnection_default_permissions(self, item: ProjectItem, rule: PermissionsRule) -> None:
+        self._default_permissions.delete_default_permission(item, rule, Resource.VirtualConnection)
+
+    @api(version="3.23")
+    def delete_database_default_permissions(self, item: ProjectItem, rule: PermissionsRule) -> None:
+        self._default_permissions.delete_default_permission(item, rule, Resource.Database)
+
+    @api(version="3.23")
+    def delete_table_default_permissions(self, item: ProjectItem, rule: PermissionsRule) -> None:
+        self._default_permissions.delete_default_permission(item, rule, Resource.Table)
+
     def filter(self, *invalid, page_size: Optional[int] = None, **kwargs) -> QuerySet[ProjectItem]:
         """
         Queries the Tableau Server for items using the specified filters. Page

tableauserverclient/server/endpoint/resource_tagger.py

@@ -1,6 +1,7 @@
 import abc
 import copy
-from typing import Generic, Iterable, Optional, Protocol, Set, TypeVar, Union, TYPE_CHECKING, runtime_checkable
+from typing import Generic, Optional, Protocol, TypeVar, Union, TYPE_CHECKING, runtime_checkable
+from collections.abc import Iterable
 import urllib.parse
 
 from tableauserverclient.server.endpoint.endpoint import Endpoint, api
@@ -24,7 +25,7 @@ if TYPE_CHECKING:
 class _ResourceTagger(Endpoint):
     # Add new tags to resource
     def _add_tags(self, baseurl, resource_id, tag_set):
-        url = "{0}/{1}/tags".format(baseurl, resource_id)
+        url = f"{baseurl}/{resource_id}/tags"
         add_req = RequestFactory.Tag.add_req(tag_set)
 
         try:
@@ -39,7 +40,7 @@ class _ResourceTagger(Endpoint):
     # Delete a resource's tag by name
     def _delete_tag(self, baseurl, resource_id, tag_name):
         encoded_tag_name = urllib.parse.quote(tag_name)
-        url = "{0}/{1}/tags/{2}".format(baseurl, resource_id, encoded_tag_name)
+        url = f"{baseurl}/{resource_id}/tags/{encoded_tag_name}"
 
         try:
             self.delete_request(url)
@@ -59,7 +60,7 @@ class _ResourceTagger(Endpoint):
             if add_set:
                 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))
+        logger.info(f"Updated tags to {resource_item.tags}")
 
 
 class Response(Protocol):
@@ -68,8 +69,8 @@ class Response(Protocol):
 
 @runtime_checkable
 class Taggable(Protocol):
-    tags: Set[str]
-    _initial_tags: Set[str]
+    tags: set[str]
+    _initial_tags: set[str]
 
     @property
     def id(self) -> Optional[str]:
@@ -95,14 +96,14 @@ class TaggingMixin(abc.ABC, Generic[T]):
     def delete_request(self, url) -> None:
         pass
 
-    def add_tags(self, item: Union[T, str], tags: Union[Iterable[str], str]) -> Set[str]:
+    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])
+            tag_set = {tags}
         else:
             tag_set = set(tags)
 
@@ -118,7 +119,7 @@ class TaggingMixin(abc.ABC, Generic[T]):
             raise ValueError("ID not found.")
 
         if isinstance(tags, str):
-            tag_set = set([tags])
+            tag_set = {tags}
         else:
             tag_set = set(tags)
 
@@ -158,9 +159,9 @@ class Tags(Endpoint):
         return f"{self.parent_srv.baseurl}/tags"
 
     @api(version="3.9")
-    def batch_add(self, tags: Union[Iterable[str], str], content: content) -> Set[str]:
+    def batch_add(self, tags: Union[Iterable[str], str], content: content) -> set[str]:
         if isinstance(tags, str):
-            tag_set = set([tags])
+            tag_set = {tags}
         else:
             tag_set = set(tags)
 
@@ -170,9 +171,9 @@ class Tags(Endpoint):
         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]:
+    def batch_delete(self, tags: Union[Iterable[str], str], content: content) -> set[str]:
         if isinstance(tags, str):
-            tag_set = set([tags])
+            tag_set = {tags}
         else:
             tag_set = set(tags)
 

tableauserverclient/server/endpoint/schedules_endpoint.py

@@ -2,7 +2,7 @@ import copy
 import logging
 import warnings
 from collections import namedtuple
-from typing import TYPE_CHECKING, Callable, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Callable, Optional, Union
 
 from .endpoint import Endpoint, api, parameter_added_in
 from .exceptions import MissingRequiredFieldError
@@ -22,14 +22,14 @@ if TYPE_CHECKING:
 class Schedules(Endpoint):
     @property
     def baseurl(self) -> str:
-        return "{0}/schedules".format(self.parent_srv.baseurl)
+        return f"{self.parent_srv.baseurl}/schedules"
 
     @property
     def siteurl(self) -> str:
-        return "{0}/sites/{1}/schedules".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/schedules"
 
     @api(version="2.3")
-    def get(self, req_options: Optional["RequestOptions"] = None) -> Tuple[List[ScheduleItem], PaginationItem]:
+    def get(self, req_options: Optional["RequestOptions"] = None) -> tuple[list[ScheduleItem], PaginationItem]:
         logger.info("Querying all schedules")
         url = self.baseurl
         server_response = self.get_request(url, req_options)
@@ -42,8 +42,8 @@ class Schedules(Endpoint):
         if not schedule_id:
             error = "No Schedule ID provided"
             raise ValueError(error)
-        logger.info("Querying a single schedule by id ({})".format(schedule_id))
-        url = "{0}/{1}".format(self.baseurl, schedule_id)
+        logger.info(f"Querying a single schedule by id ({schedule_id})")
+        url = f"{self.baseurl}/{schedule_id}"
         server_response = self.get_request(url)
         return ScheduleItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
@@ -52,9 +52,9 @@ class Schedules(Endpoint):
         if not schedule_id:
             error = "Schedule ID undefined"
             raise ValueError(error)
-        url = "{0}/{1}".format(self.baseurl, schedule_id)
+        url = f"{self.baseurl}/{schedule_id}"
         self.delete_request(url)
-        logger.info("Deleted single schedule (ID: {0})".format(schedule_id))
+        logger.info(f"Deleted single schedule (ID: {schedule_id})")
 
     @api(version="2.3")
     def update(self, schedule_item: ScheduleItem) -> ScheduleItem:
@@ -62,10 +62,10 @@ class Schedules(Endpoint):
             error = "Schedule item missing ID."
             raise MissingRequiredFieldError(error)
 
-        url = "{0}/{1}".format(self.baseurl, schedule_item.id)
+        url = f"{self.baseurl}/{schedule_item.id}"
         update_req = RequestFactory.Schedule.update_req(schedule_item)
         server_response = self.put_request(url, update_req)
-        logger.info("Updated schedule item (ID: {})".format(schedule_item.id))
+        logger.info(f"Updated schedule item (ID: {schedule_item.id})")
         updated_schedule = copy.copy(schedule_item)
         return updated_schedule._parse_common_tags(server_response.content, self.parent_srv.namespace)
 
@@ -79,7 +79,7 @@ class Schedules(Endpoint):
         create_req = RequestFactory.Schedule.create_req(schedule_item)
         server_response = self.post_request(url, create_req)
         new_schedule = ScheduleItem.from_response(server_response.content, self.parent_srv.namespace)[0]
-        logger.info("Created new schedule (ID: {})".format(new_schedule.id))
+        logger.info(f"Created new schedule (ID: {new_schedule.id})")
         return new_schedule
 
     @api(version="2.8")
@@ -91,12 +91,12 @@ class Schedules(Endpoint):
         datasource: Optional["DatasourceItem"] = None,
         flow: Optional["FlowItem"] = None,
         task_type: Optional[str] = None,
-    ) -> List[AddResponse]:
+    ) -> list[AddResponse]:
         # There doesn't seem to be a good reason to allow one item of each type?
         if workbook and datasource:
             warnings.warn("Passing in multiple items for add_to_schedule will be deprecated", PendingDeprecationWarning)
-        items: List[
-            Tuple[str, Union[WorkbookItem, FlowItem, DatasourceItem], str, Callable[[Optional[str], str], bytes], str]
+        items: list[
+            tuple[str, Union[WorkbookItem, FlowItem, DatasourceItem], str, Callable[[Optional[str], str], bytes], str]
         ] = []
 
         if workbook is not None:
@@ -115,8 +115,7 @@ class Schedules(Endpoint):
             )  # type:ignore[arg-type]
 
         results = (self._add_to(*x) for x in items)
-        # list() is needed for python 3.x compatibility
-        return list(filter(lambda x: not x.result, results))  # type:ignore[arg-type]
+        return [x for x in results if not x.result]
 
     def _add_to(
         self,
@@ -133,13 +132,13 @@ class Schedules(Endpoint):
         item_task_type,
     ) -> AddResponse:
         id_ = resource.id
-        url = "{0}/{1}/{2}s".format(self.siteurl, schedule_id, type_)
+        url = f"{self.siteurl}/{schedule_id}/{type_}s"
         add_req = req_factory(id_, task_type=item_task_type)  # type: ignore[call-arg, arg-type]
         response = self.put_request(url, add_req)
 
         error, warnings, task_created = ScheduleItem.parse_add_to_schedule_response(response, self.parent_srv.namespace)
         if task_created:
-            logger.info("Added {} to {} to schedule {}".format(type_, id_, schedule_id))
+            logger.info(f"Added {type_} to {id_} to schedule {schedule_id}")
 
         if error is not None or warnings is not None:
             return AddResponse(

tableauserverclient/server/endpoint/server_info_endpoint.py

@@ -1,4 +1,5 @@
 import logging
+from typing import Union
 
 from .endpoint import Endpoint, api
 from .exceptions import ServerResponseError
@@ -21,15 +22,49 @@ class ServerInfo(Endpoint):
         return self._info
 
     def __repr__(self):
-        return "<Endpoint {}>".format(self.serverInfo)
+        return f"<Endpoint {self.serverInfo}>"
 
     @property
-    def baseurl(self):
-        return "{0}/serverInfo".format(self.parent_srv.baseurl)
+    def baseurl(self) -> str:
+        return f"{self.parent_srv.baseurl}/serverInfo"
 
     @api(version="2.4")
-    def get(self):
-        """Retrieve the server info for the server.  This is an unauthenticated call"""
+    def get(self) -> Union[ServerInfoItem, None]:
+        """
+        Retrieve the build and version information for the server.
+
+        This method makes an unauthenticated call, so no sign in or
+        authentication token is required.
+
+        Returns
+        -------
+        :class:`~tableauserverclient.models.ServerInfoItem`
+
+        Raises
+        ------
+        :class:`~tableauserverclient.exceptions.ServerInfoEndpointNotFoundError`
+            Raised when the server info endpoint is not found.
+
+        :class:`~tableauserverclient.exceptions.EndpointUnavailableError`
+            Raised when the server info endpoint is not available.
+
+        Examples
+        --------
+        >>> import tableauserverclient as TSC
+
+        >>> # create a instance of server
+        >>> server = TSC.Server('https://MY-SERVER')
+
+        >>> # set the version number > 2.3
+        >>> # the server_info.get() method works in 2.4 and later
+        >>> server.version = '2.5'
+
+        >>> s_info = server.server_info.get()
+        >>> print("\nServer info:")
+        >>> print("\tProduct version: {0}".format(s_info.product_version))
+        >>> print("\tREST API version: {0}".format(s_info.rest_api_version))
+        >>> print("\tBuild number: {0}".format(s_info.build_number))
+        """
         try:
             server_response = self.get_unauthenticated_request(self.baseurl)
         except ServerResponseError as e: