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

tableauserverclient/server/endpoint/projects_endpoint.py

@@ -1,22 +1,24 @@
 import logging
 
-from .default_permissions_endpoint import _DefaultPermissionsEndpoint
-from .endpoint import QuerysetEndpoint, api, XML_CONTENT_TYPE
-from .exceptions import MissingRequiredFieldError
-from .permissions_endpoint import _PermissionsEndpoint
+from tableauserverclient.server.endpoint.default_permissions_endpoint import _DefaultPermissionsEndpoint
+from tableauserverclient.server.endpoint.endpoint import QuerysetEndpoint, api, XML_CONTENT_TYPE
+from tableauserverclient.server.endpoint.exceptions import MissingRequiredFieldError
+from tableauserverclient.server.endpoint.permissions_endpoint import _PermissionsEndpoint
 from tableauserverclient.server import RequestFactory, RequestOptions
 from tableauserverclient.models import ProjectItem, PaginationItem, Resource
 
 from typing import List, Optional, Tuple, TYPE_CHECKING
 
+from tableauserverclient.server.query import QuerySet
+
 if TYPE_CHECKING:
-    from ..server import Server
-    from ..request_options import RequestOptions
+    from tableauserverclient.server.server import Server
+    from tableauserverclient.server.request_options import RequestOptions
 
 from tableauserverclient.helpers.logging import logger
 
 
-class Projects(QuerysetEndpoint):
+class Projects(QuerysetEndpoint[ProjectItem]):
     def __init__(self, parent_srv: "Server") -> None:
         super(Projects, self).__init__(parent_srv)
 
@@ -75,17 +77,6 @@ class Projects(QuerysetEndpoint):
     def populate_permissions(self, item: ProjectItem) -> None:
         self._permissions.populate(item)
 
-    @api(version="2.0")
-    def update_permission(self, item, rules):
-        import warnings
-
-        warnings.warn(
-            "Server.projects.update_permission is deprecated, "
-            "please use Server.projects.update_permissions instead.",
-            DeprecationWarning,
-        )
-        return self._permissions.update(item, rules)
-
     @api(version="2.0")
     def update_permissions(self, item, rules):
         return self._permissions.update(item, rules)
@@ -165,3 +156,44 @@ class Projects(QuerysetEndpoint):
     @api(version="3.4")
     def delete_lens_default_permissions(self, item, rule):
         self._default_permissions.delete_default_permission(item, rule, Resource.Lens)
+
+    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)

tableauserverclient/server/endpoint/resource_tagger.py

@@ -1,14 +1,25 @@
+import abc
 import copy
+from typing import Generic, Iterable, Optional, Protocol, Set, TypeVar, Union, TYPE_CHECKING, runtime_checkable
 import urllib.parse
 
-from .endpoint import Endpoint
-from .exceptions import ServerResponseError
-from ..exceptions import EndpointUnavailableError
+from tableauserverclient.server.endpoint.endpoint import Endpoint, api
+from tableauserverclient.server.endpoint.exceptions import ServerResponseError
+from tableauserverclient.server.exceptions import EndpointUnavailableError
 from tableauserverclient.server import RequestFactory
 from tableauserverclient.models import TagItem
 
 from tableauserverclient.helpers.logging import logger
 
+if TYPE_CHECKING:
+    from tableauserverclient.models.column_item import ColumnItem
+    from tableauserverclient.models.database_item import DatabaseItem
+    from tableauserverclient.models.datasource_item import DatasourceItem
+    from tableauserverclient.models.flow_item import FlowItem
+    from tableauserverclient.models.table_item import TableItem
+    from tableauserverclient.models.workbook_item import WorkbookItem
+    from tableauserverclient.server.server import Server
+
 
 class _ResourceTagger(Endpoint):
     # Add new tags to resource
@@ -49,3 +60,124 @@ class _ResourceTagger(Endpoint):
                 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))
+
+
+class Response(Protocol):
+    content: bytes
+
+
+@runtime_checkable
+class Taggable(Protocol):
+    tags: Set[str]
+    _initial_tags: Set[str]
+
+    @property
+    def id(self) -> Optional[str]:
+        pass
+
+
+T = TypeVar("T")
+
+
+class TaggingMixin(abc.ABC, Generic[T]):
+    parent_srv: "Server"
+
+    @property
+    @abc.abstractmethod
+    def baseurl(self) -> str:
+        pass
+
+    @abc.abstractmethod
+    def put_request(self, url, request) -> Response:
+        pass
+
+    @abc.abstractmethod
+    def delete_request(self, url) -> None:
+        pass
+
+    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])
+        else:
+            tag_set = set(tags)
+
+        url = f"{self.baseurl}/{item_id}/tags"
+        add_req = RequestFactory.Tag.add_req(tag_set)
+        server_response = self.put_request(url, add_req)
+        return TagItem.from_response(server_response.content, self.parent_srv.namespace)
+
+    def delete_tags(self, item: Union[T, str], tags: Union[Iterable[str], str]) -> None:
+        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])
+        else:
+            tag_set = set(tags)
+
+        for tag in tag_set:
+            encoded_tag_name = urllib.parse.quote(tag)
+            url = f"{self.baseurl}/{item_id}/tags/{encoded_tag_name}"
+            self.delete_request(url)
+
+    def update_tags(self, item: T) -> None:
+        if (initial_tags := getattr(item, "_initial_tags", None)) is None:
+            raise ValueError(f"{item} does not have initial tags.")
+        if (tags := getattr(item, "tags", None)) is None:
+            raise ValueError(f"{item} does not have tags.")
+        if tags == initial_tags:
+            return
+
+        add_set = tags - initial_tags
+        remove_set = initial_tags - tags
+        self.delete_tags(item, remove_set)
+        if add_set:
+            tags = self.add_tags(item, add_set)
+            setattr(item, "tags", tags)
+
+        setattr(item, "_initial_tags", copy.copy(tags))
+        logger.info(f"Updated tags to {tags}")
+
+
+content = Iterable[Union["ColumnItem", "DatabaseItem", "DatasourceItem", "FlowItem", "TableItem", "WorkbookItem"]]
+
+
+class Tags(Endpoint):
+    def __init__(self, parent_srv: "Server"):
+        super().__init__(parent_srv)
+
+    @property
+    def baseurl(self):
+        return f"{self.parent_srv.baseurl}/tags"
+
+    @api(version="3.9")
+    def batch_add(self, tags: Union[Iterable[str], str], content: content) -> Set[str]:
+        if isinstance(tags, str):
+            tag_set = set([tags])
+        else:
+            tag_set = set(tags)
+
+        url = f"{self.baseurl}:batchCreate"
+        batch_create_req = RequestFactory.Tag.batch_create(tag_set, content)
+        server_response = self.put_request(url, batch_create_req)
+        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]:
+        if isinstance(tags, str):
+            tag_set = set([tags])
+        else:
+            tag_set = set(tags)
+
+        url = f"{self.baseurl}:batchDelete"
+        # The batch delete XML is the same as the batch create XML.
+        batch_delete_req = RequestFactory.Tag.batch_create(tag_set, content)
+        server_response = self.put_request(url, batch_delete_req)
+        return TagItem.from_response(server_response.content, self.parent_srv.namespace)

tableauserverclient/server/endpoint/tables_endpoint.py

@@ -1,17 +1,19 @@
 import logging
+from typing import Iterable, Set, Union
 
-from .dqw_endpoint import _DataQualityWarningEndpoint
-from .endpoint import api, Endpoint
-from .exceptions import MissingRequiredFieldError
-from .permissions_endpoint import _PermissionsEndpoint
+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 TableItem, ColumnItem, PaginationItem
-from ..pager import Pager
+from tableauserverclient.server.pager import Pager
 
 from tableauserverclient.helpers.logging import logger
 
 
-class Tables(Endpoint):
+class Tables(Endpoint, TaggingMixin[TableItem]):
     def __init__(self, parent_srv):
         super(Tables, self).__init__(parent_srv)
 
@@ -101,16 +103,6 @@ class Tables(Endpoint):
     def populate_permissions(self, item):
         self._permissions.populate(item)
 
-    @api(version="3.5")
-    def update_permission(self, item, rules):
-        import warnings
-
-        warnings.warn(
-            "Server.tables.update_permission is deprecated, " "please use Server.tables.update_permissions instead.",
-            DeprecationWarning,
-        )
-        return self._permissions.update(item, rules)
-
     @api(version="3.5")
     def update_permissions(self, item, rules):
         return self._permissions.update(item, rules)
@@ -134,3 +126,14 @@ class Tables(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[TableItem, str], tags: Union[Iterable[str], str]) -> Set[str]:
+        return super().add_tags(item, tags)
+
+    @api(version="3.9")
+    def delete_tags(self, item: Union[TableItem, str], tags: Union[Iterable[str], str]) -> None:
+        return super().delete_tags(item, tags)
+
+    def update_tags(self, item: TableItem) -> None:  # type: ignore
+        raise NotImplementedError("Update tags is not implemented for TableItem")

tableauserverclient/server/endpoint/users_endpoint.py

@@ -2,6 +2,8 @@ import copy
 import logging
 from typing import List, Optional, Tuple
 
+from tableauserverclient.server.query import QuerySet
+
 from .endpoint import QuerysetEndpoint, api
 from .exceptions import MissingRequiredFieldError, ServerResponseError
 from tableauserverclient.server import RequestFactory, RequestOptions
@@ -11,7 +13,7 @@ from ..pager import Pager
 from tableauserverclient.helpers.logging import logger
 
 
-class Users(QuerysetEndpoint):
+class Users(QuerysetEndpoint[UserItem]):
     @property
     def baseurl(self) -> str:
         return "{0}/sites/{1}/users".format(self.parent_srv.baseurl, self.parent_srv.site_id)
@@ -166,3 +168,40 @@ class Users(QuerysetEndpoint):
         group_item = GroupItem.from_response(server_response.content, self.parent_srv.namespace)
         pagination_item = PaginationItem.from_response(server_response.content, self.parent_srv.namespace)
         return group_item, pagination_item
+
+    def filter(self, *invalid, page_size: Optional[int] = None, **kwargs) -> QuerySet[UserItem]:
+        """
+        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:
+
+
+        domain_name=...
+        domain_name__in=...
+        friendly_name=...
+        friendly_name__in=...
+        is_local=...
+        last_login=...
+        last_login__gt=...
+        last_login__gte=...
+        last_login__lt=...
+        last_login__lte=...
+        luid=...
+        luid__in=...
+        name__cieq=...
+        name=...
+        name__in=...
+        site_role=...
+        site_role__in=...
+        """
+
+        return super().filter(*invalid, page_size=page_size, **kwargs)

tableauserverclient/server/endpoint/views_endpoint.py

@@ -1,18 +1,20 @@
 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 Iterable, Iterator, List, Optional, Set, Tuple, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
-    from ..request_options import (
+    from tableauserverclient.server.request_options import (
         RequestOptions,
         CSVRequestOptions,
         PDFRequestOptions,
@@ -21,10 +23,9 @@ if TYPE_CHECKING:
     )
 
 
-class Views(QuerysetEndpoint):
+class Views(QuerysetEndpoint[ViewItem], TaggingMixin[ViewItem]):
     def __init__(self, parent_srv):
         super(Views, self).__init__(parent_srv)
-        self._resource_tagger = _ResourceTagger(parent_srv)
         self._permissions = _PermissionsEndpoint(parent_srv, lambda: self.baseurl)
 
     # Used because populate_preview_image functionaliy requires workbook endpoint
@@ -50,12 +51,14 @@ class Views(QuerysetEndpoint):
         return all_view_items, pagination_item
 
     @api(version="3.1")
-    def get_by_id(self, view_id: str) -> ViewItem:
+    def get_by_id(self, view_id: str, usage: bool = False) -> 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)
+        if usage:
+            url += "?includeUsageStatistics=true"
         server_response = self.get_request(url)
         return ViewItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
@@ -167,7 +170,91 @@ class Views(QuerysetEndpoint):
             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,173 @@
+from functools import partial
+import json
+from pathlib import Path
+from typing import Iterable, List, Optional, Set, TYPE_CHECKING, Tuple, Union
+
+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")