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

tableauserverclient/server/endpoint/metadata_endpoint.py

@@ -50,11 +50,11 @@ def get_page_info(result):
 class Metadata(Endpoint):
     @property
     def baseurl(self):
-        return "{0}/api/metadata/graphql".format(self.parent_srv.server_address)
+        return f"{self.parent_srv.server_address}/api/metadata/graphql"
 
     @property
     def control_baseurl(self):
-        return "{0}/api/metadata/v1/control".format(self.parent_srv.server_address)
+        return f"{self.parent_srv.server_address}/api/metadata/v1/control"
 
     @api("3.5")
     def query(self, query, variables=None, abort_on_error=False, parameters=None):

tableauserverclient/server/endpoint/metrics_endpoint.py

@@ -8,7 +8,7 @@ from tableauserverclient.models import MetricItem, PaginationItem
 
 import logging
 
-from typing import List, Optional, TYPE_CHECKING, Tuple
+from typing import Optional, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from ..request_options import RequestOptions
@@ -20,18 +20,18 @@ from tableauserverclient.helpers.logging import logger
 
 class Metrics(QuerysetEndpoint[MetricItem]):
     def __init__(self, parent_srv: "Server") -> None:
-        super(Metrics, self).__init__(parent_srv)
+        super().__init__(parent_srv)
         self._resource_tagger = _ResourceTagger(parent_srv)
         self._permissions = _PermissionsEndpoint(parent_srv, lambda: self.baseurl)
         self._data_quality_warnings = _DataQualityWarningEndpoint(self.parent_srv, "metric")
 
     @property
     def baseurl(self) -> str:
-        return "{0}/sites/{1}/metrics".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/metrics"
 
     # Get all metrics
     @api(version="3.9")
-    def get(self, req_options: Optional["RequestOptions"] = None) -> Tuple[List[MetricItem], PaginationItem]:
+    def get(self, req_options: Optional["RequestOptions"] = None) -> tuple[list[MetricItem], PaginationItem]:
         logger.info("Querying all metrics on site")
         url = self.baseurl
         server_response = self.get_request(url, req_options)
@@ -45,8 +45,8 @@ class Metrics(QuerysetEndpoint[MetricItem]):
         if not metric_id:
             error = "Metric ID undefined."
             raise ValueError(error)
-        logger.info("Querying single metric (ID: {0})".format(metric_id))
-        url = "{0}/{1}".format(self.baseurl, metric_id)
+        logger.info(f"Querying single metric (ID: {metric_id})")
+        url = f"{self.baseurl}/{metric_id}"
         server_response = self.get_request(url)
         return MetricItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
@@ -56,9 +56,9 @@ class Metrics(QuerysetEndpoint[MetricItem]):
         if not metric_id:
             error = "Metric ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}".format(self.baseurl, metric_id)
+        url = f"{self.baseurl}/{metric_id}"
         self.delete_request(url)
-        logger.info("Deleted single metric (ID: {0})".format(metric_id))
+        logger.info(f"Deleted single metric (ID: {metric_id})")
 
     # Update metric
     @api(version="3.9")
@@ -70,8 +70,8 @@ class Metrics(QuerysetEndpoint[MetricItem]):
         self._resource_tagger.update_tags(self.baseurl, metric_item)
 
         # Update the metric itself
-        url = "{0}/{1}".format(self.baseurl, metric_item.id)
+        url = f"{self.baseurl}/{metric_item.id}"
         update_req = RequestFactory.Metric.update_req(metric_item)
         server_response = self.put_request(url, update_req)
-        logger.info("Updated metric item (ID: {0})".format(metric_item.id))
+        logger.info(f"Updated metric item (ID: {metric_item.id})")
         return MetricItem.from_response(server_response.content, self.parent_srv.namespace)[0]

tableauserverclient/server/endpoint/permissions_endpoint.py

@@ -6,7 +6,7 @@ from tableauserverclient.models import TableauItem, PermissionsRule
 from .endpoint import Endpoint
 from .exceptions import MissingRequiredFieldError
 
-from typing import Callable, TYPE_CHECKING, List, Optional, Union
+from typing import Callable, TYPE_CHECKING, Optional, Union
 
 from tableauserverclient.helpers.logging import logger
 
@@ -25,7 +25,7 @@ class _PermissionsEndpoint(Endpoint):
     """
 
     def __init__(self, parent_srv: "Server", owner_baseurl: Callable[[], str]) -> None:
-        super(_PermissionsEndpoint, self).__init__(parent_srv)
+        super().__init__(parent_srv)
 
         # owner_baseurl is the baseurl of the parent.  The MUST be a lambda
         # since we don't know the full site URL until we sign in.  If
@@ -33,18 +33,18 @@ class _PermissionsEndpoint(Endpoint):
         self.owner_baseurl = owner_baseurl
 
     def __str__(self):
-        return "<PermissionsEndpoint baseurl={}>".format(self.owner_baseurl)
+        return f"<PermissionsEndpoint baseurl={self.owner_baseurl}>"
 
-    def update(self, resource: TableauItem, permissions: List[PermissionsRule]) -> List[PermissionsRule]:
-        url = "{0}/{1}/permissions".format(self.owner_baseurl(), resource.id)
+    def update(self, resource: TableauItem, permissions: list[PermissionsRule]) -> list[PermissionsRule]:
+        url = f"{self.owner_baseurl()}/{resource.id}/permissions"
         update_req = RequestFactory.Permission.add_req(permissions)
         response = self.put_request(url, update_req)
         permissions = PermissionsRule.from_response(response.content, self.parent_srv.namespace)
-        logger.info("Updated permissions for resource {0}: {1}".format(resource.id, permissions))
+        logger.info(f"Updated permissions for resource {resource.id}: {permissions}")
 
         return permissions
 
-    def delete(self, resource: TableauItem, rules: Union[PermissionsRule, List[PermissionsRule]]):
+    def delete(self, resource: TableauItem, rules: Union[PermissionsRule, list[PermissionsRule]]):
         # Delete is the only endpoint that doesn't take a list of rules
         # so let's fake it to keep it consistent
         # TODO that means we need error handling around the call
@@ -54,7 +54,7 @@ class _PermissionsEndpoint(Endpoint):
         for rule in rules:
             for capability, mode in rule.capabilities.items():
                 "/permissions/groups/group-id/capability-name/capability-mode"
-                url = "{0}/{1}/permissions/{2}/{3}/{4}/{5}".format(
+                url = "{}/{}/permissions/{}/{}/{}/{}".format(
                     self.owner_baseurl(),
                     resource.id,
                     rule.grantee.tag_name + "s",
@@ -63,13 +63,11 @@ class _PermissionsEndpoint(Endpoint):
                     mode,
                 )
 
-                logger.debug("Removing {0} permission for capability {1}".format(mode, capability))
+                logger.debug(f"Removing {mode} permission for capability {capability}")
 
                 self.delete_request(url)
 
-            logger.info(
-                "Deleted permission for {0} {1} item {2}".format(rule.grantee.tag_name, rule.grantee.id, resource.id)
-            )
+            logger.info(f"Deleted permission for {rule.grantee.tag_name} {rule.grantee.id} item {resource.id}")
 
     def populate(self, item: TableauItem):
         if not item.id:
@@ -80,12 +78,12 @@ class _PermissionsEndpoint(Endpoint):
             return self._get_permissions(item)
 
         item._set_permissions(permission_fetcher)
-        logger.info("Populated permissions for item (ID: {0})".format(item.id))
+        logger.info(f"Populated permissions for item (ID: {item.id})")
 
     def _get_permissions(self, item: TableauItem, req_options: Optional["RequestOptions"] = None):
-        url = "{0}/{1}/permissions".format(self.owner_baseurl(), item.id)
+        url = f"{self.owner_baseurl()}/{item.id}/permissions"
         server_response = self.get_request(url, req_options)
         permissions = PermissionsRule.from_response(server_response.content, self.parent_srv.namespace)
-        logger.info("Permissions for resource {0}: {1}".format(item.id, permissions))
+        logger.info(f"Permissions for resource {item.id}: {permissions}")
 
         return permissions