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

tableauserverclient/server/endpoint/jobs_endpoint.py

@@ -1,25 +1,38 @@
 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
 
-from typing import List, Optional, Tuple, Union
+from typing import Optional, 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)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/jobs"
+
+    @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
@@ -40,13 +53,13 @@ class Jobs(QuerysetEndpoint[JobItem]):
         if isinstance(job_id, JobItem):
             job_id = job_id.id
         assert isinstance(job_id, str)
-        url = "{0}/{1}".format(self.baseurl, job_id)
+        url = f"{self.baseurl}/{job_id}"
         return self.put_request(url)
 
     @api(version="2.6")
     def get_by_id(self, job_id: str) -> JobItem:
         logger.info("Query for information about job " + job_id)
-        url = "{0}/{1}".format(self.baseurl, job_id)
+        url = f"{self.baseurl}/{job_id}"
         server_response = self.get_request(url)
         new_job = JobItem.from_response(server_response.content, self.parent_srv.namespace)[0]
         return new_job
@@ -64,7 +77,7 @@ class Jobs(QuerysetEndpoint[JobItem]):
             job = self.get_by_id(job_id)
             logger.debug(f"\tJob {job_id} progress={job.progress}")
 
-        logger.info("Job {} Completed: Finish Code: {} - Notes:{}".format(job_id, job.finish_code, job.notes))
+        logger.info(f"Job {job_id} Completed: Finish Code: {job.finish_code} - Notes:{job.notes}")
 
         if job.finish_code == JobItem.FinishCode.Success:
             return job
@@ -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 Optional, 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/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

tableauserverclient/server/endpoint/projects_endpoint.py

@@ -5,9 +5,12 @@ 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
 
 if TYPE_CHECKING:
     from tableauserverclient.server.server import Server
@@ -18,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)
@@ -41,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:
@@ -52,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
 
@@ -64,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")
@@ -76,81 +79,172 @@ 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
+        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)