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

tableauserverclient/models/tag_item.py

@@ -1,16 +1,15 @@
 import xml.etree.ElementTree as ET
-from typing import Set
 
 from defusedxml.ElementTree import fromstring
 
 
-class TagItem(object):
+class TagItem:
     @classmethod
-    def from_response(cls, resp: bytes, ns) -> Set[str]:
+    def from_response(cls, resp: bytes, ns) -> set[str]:
         return cls.from_xml_element(fromstring(resp), ns)
 
     @classmethod
-    def from_xml_element(cls, parsed_response: ET.Element, ns) -> Set[str]:
+    def from_xml_element(cls, parsed_response: ET.Element, ns) -> set[str]:
         all_tags = set()
         tag_elem = parsed_response.findall(".//t:tag", namespaces=ns)
         for tag_xml in tag_elem:

tableauserverclient/models/task_item.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import List, Optional
+from typing import Optional
 
 from defusedxml.ElementTree import fromstring
 
@@ -8,7 +8,7 @@ from tableauserverclient.models.schedule_item import ScheduleItem
 from tableauserverclient.models.target import Target
 
 
-class TaskItem(object):
+class TaskItem:
     class Type:
         ExtractRefresh = "extractRefresh"
         DataAcceleration = "dataAcceleration"
@@ -48,9 +48,9 @@ class TaskItem(object):
         )
 
     @classmethod
-    def from_response(cls, xml, ns, task_type=Type.ExtractRefresh) -> List["TaskItem"]:
+    def from_response(cls, xml, ns, task_type=Type.ExtractRefresh) -> list["TaskItem"]:
         parsed_response = fromstring(xml)
-        all_tasks_xml = parsed_response.findall(".//t:task/t:{}".format(task_type), namespaces=ns)
+        all_tasks_xml = parsed_response.findall(f".//t:task/t:{task_type}", namespaces=ns)
 
         all_tasks = (TaskItem._parse_element(x, ns) for x in all_tasks_xml)
 

tableauserverclient/models/user_item.py

@@ -2,7 +2,7 @@ import io
 import xml.etree.ElementTree as ET
 from datetime import datetime
 from enum import IntEnum
-from typing import Dict, List, Optional, TYPE_CHECKING, Tuple
+from typing import Optional, TYPE_CHECKING
 
 from defusedxml.ElementTree import fromstring
 
@@ -18,10 +18,35 @@ if TYPE_CHECKING:
     from tableauserverclient.server import Pager
 
 
-class UserItem(object):
+class UserItem:
+    """
+    The UserItem class contains the members or attributes for the view
+    resources on Tableau Server. The UserItem class defines the information you
+    can request or query from Tableau Server. The class attributes correspond
+    to the attributes of a server request or response payload.
+
+
+    Parameters
+    ----------
+    name: str
+        The name of the user.
+
+    site_role: str
+        The role of the user on the site.
+
+    auth_setting: str
+        Required attribute for Tableau Cloud. How the user autenticates to the
+        server.
+    """
+
     tag_name: str = "user"
 
     class Roles:
+        """
+        The Roles class contains the possible roles for a user on Tableau
+        Server.
+        """
+
         Interactor = "Interactor"
         Publisher = "Publisher"
         ServerAdministrator = "ServerAdministrator"
@@ -43,6 +68,11 @@ class UserItem(object):
         SupportUser = "SupportUser"
 
     class Auth:
+        """
+        The Auth class contains the possible authentication settings for a user
+        on Tableau Cloud.
+        """
+
         OpenID = "OpenID"
         SAML = "SAML"
         TableauIDWithMFA = "TableauIDWithMFA"
@@ -57,7 +87,7 @@ class UserItem(object):
         self._id: Optional[str] = None
         self._last_login: Optional[datetime] = None
         self._workbooks = None
-        self._favorites: Optional[Dict[str, List]] = None
+        self._favorites: Optional[dict[str, list]] = None
         self._groups = None
         self.email: Optional[str] = None
         self.fullname: Optional[str] = None
@@ -69,7 +99,7 @@ class UserItem(object):
 
     def __str__(self) -> str:
         str_site_role = self.site_role or "None"
-        return "<User {} name={} role={}>".format(self.id, self.name, str_site_role)
+        return f"<User {self.id} name={self.name} role={str_site_role}>"
 
     def __repr__(self):
         return self.__str__() + "  { " + ", ".join(" % s: % s" % item for item in vars(self).items()) + "}"
@@ -141,7 +171,7 @@ class UserItem(object):
         return self._workbooks()
 
     @property
-    def favorites(self) -> Dict[str, List]:
+    def favorites(self) -> dict[str, list]:
         if self._favorites is None:
             error = "User item must be populated with favorites first."
             raise UnpopulatedPropertyError(error)
@@ -210,12 +240,12 @@ class UserItem(object):
             self._domain_name = domain_name
 
     @classmethod
-    def from_response(cls, resp, ns) -> List["UserItem"]:
+    def from_response(cls, resp, ns) -> list["UserItem"]:
         element_name = ".//t:user"
         return cls._parse_xml(element_name, resp, ns)
 
     @classmethod
-    def from_response_as_owner(cls, resp, ns) -> List["UserItem"]:
+    def from_response_as_owner(cls, resp, ns) -> list["UserItem"]:
         element_name = ".//t:owner"
         return cls._parse_xml(element_name, resp, ns)
 
@@ -283,7 +313,7 @@ class UserItem(object):
             domain_name,
         )
 
-    class CSVImport(object):
+    class CSVImport:
         """
         This class includes hardcoded options and logic for the CSV file format defined for user import
         https://help.tableau.com/current/server/en-us/users_import.htm
@@ -308,7 +338,7 @@ class UserItem(object):
             if line is None or line is False or line == "\n" or line == "":
                 return None
             line = line.strip().lower()
-            values: List[str] = list(map(str.strip, line.split(",")))
+            values: list[str] = list(map(str.strip, line.split(",")))
             user = UserItem(values[UserItem.CSVImport.ColumnType.USERNAME])
             if len(values) > 1:
                 if len(values) > UserItem.CSVImport.ColumnType.MAX:
@@ -337,7 +367,7 @@ class UserItem(object):
         # Read through an entire CSV file meant for user import
         # Return the number of valid lines and a list of all the invalid lines
         @staticmethod
-        def validate_file_for_import(csv_file: io.TextIOWrapper, logger) -> Tuple[int, List[str]]:
+        def validate_file_for_import(csv_file: io.TextIOWrapper, logger) -> tuple[int, list[str]]:
             num_valid_lines = 0
             invalid_lines = []
             csv_file.seek(0)  # set to start of file in case it has been read earlier
@@ -345,11 +375,11 @@ class UserItem(object):
             while line and line != "":
                 try:
                     # do not print passwords
-                    logger.info("Reading user {}".format(line[:4]))
+                    logger.info(f"Reading user {line[:4]}")
                     UserItem.CSVImport._validate_import_line_or_throw(line, logger)
                     num_valid_lines += 1
                 except Exception as exc:
-                    logger.info("Error parsing {}: {}".format(line[:4], exc))
+                    logger.info(f"Error parsing {line[:4]}: {exc}")
                     invalid_lines.append(line)
                 line = csv_file.readline()
             return num_valid_lines, invalid_lines
@@ -358,7 +388,7 @@ class UserItem(object):
         # Iterate through each field and validate the given value against hardcoded constraints
         @staticmethod
         def _validate_import_line_or_throw(incoming, logger) -> None:
-            _valid_attributes: List[List[str]] = [
+            _valid_attributes: list[list[str]] = [
                 [],
                 [],
                 [],
@@ -373,23 +403,23 @@ class UserItem(object):
             if len(line) > UserItem.CSVImport.ColumnType.MAX:
                 raise AttributeError("Too many attributes in line")
             username = line[UserItem.CSVImport.ColumnType.USERNAME.value]
-            logger.debug("> details - {}".format(username))
+            logger.debug(f"> details - {username}")
             UserItem.validate_username_or_throw(username)
             for i in range(1, len(line)):
-                logger.debug("column {}: {}".format(UserItem.CSVImport.ColumnType(i).name, line[i]))
+                logger.debug(f"column {UserItem.CSVImport.ColumnType(i).name}: {line[i]}")
                 UserItem.CSVImport._validate_attribute_value(
                     line[i], _valid_attributes[i], UserItem.CSVImport.ColumnType(i)
                 )
 
         # Given a restricted set of possible values, confirm the item is in that set
         @staticmethod
-        def _validate_attribute_value(item: str, possible_values: List[str], column_type) -> None:
+        def _validate_attribute_value(item: str, possible_values: list[str], column_type) -> None:
             if item is None or item == "":
                 # value can be empty for any column except user, which is checked elsewhere
                 return
             if item in possible_values or possible_values == []:
                 return
-            raise AttributeError("Invalid value {} for {}".format(item, column_type))
+            raise AttributeError(f"Invalid value {item} for {column_type}")
 
         # https://help.tableau.com/current/server/en-us/csvguidelines.htm#settings_and_site_roles
         # This logic is hardcoded to match the existing rules for import csv files

tableauserverclient/models/view_item.py

@@ -1,7 +1,8 @@
 import copy
 from datetime import datetime
 from requests import Response
-from typing import Callable, Iterator, List, Optional, Set
+from typing import Callable, Optional
+from collections.abc import Iterator
 
 from defusedxml.ElementTree import fromstring
 
@@ -11,13 +12,13 @@ from .permissions_item import PermissionsRule
 from .tag_item import TagItem
 
 
-class ViewItem(object):
+class ViewItem:
     def __init__(self) -> None:
         self._content_url: Optional[str] = None
         self._created_at: Optional[datetime] = None
         self._id: Optional[str] = None
         self._image: Optional[Callable[[], bytes]] = None
-        self._initial_tags: Set[str] = set()
+        self._initial_tags: set[str] = set()
         self._name: Optional[str] = None
         self._owner_id: Optional[str] = None
         self._preview_image: Optional[Callable[[], bytes]] = None
@@ -29,15 +30,15 @@ class ViewItem(object):
         self._sheet_type: Optional[str] = None
         self._updated_at: Optional[datetime] = None
         self._workbook_id: Optional[str] = None
-        self._permissions: Optional[Callable[[], List[PermissionsRule]]] = None
-        self.tags: Set[str] = set()
+        self._permissions: Optional[Callable[[], list[PermissionsRule]]] = None
+        self.tags: set[str] = set()
         self._data_acceleration_config = {
             "acceleration_enabled": None,
             "acceleration_status": None,
         }
 
     def __str__(self):
-        return "<ViewItem {0} '{1}' contentUrl='{2}' project={3}>".format(
+        return "<ViewItem {} '{}' contentUrl='{}' project={}>".format(
             self._id, self.name, self.content_url, self.project_id
         )
 
@@ -146,21 +147,21 @@ class ViewItem(object):
         self._data_acceleration_config = value
 
     @property
-    def permissions(self) -> List[PermissionsRule]:
+    def permissions(self) -> list[PermissionsRule]:
         if self._permissions is None:
             error = "View item must be populated with permissions first."
             raise UnpopulatedPropertyError(error)
         return self._permissions()
 
-    def _set_permissions(self, permissions: Callable[[], List[PermissionsRule]]) -> None:
+    def _set_permissions(self, permissions: Callable[[], list[PermissionsRule]]) -> None:
         self._permissions = permissions
 
     @classmethod
-    def from_response(cls, resp: "Response", ns, workbook_id="") -> List["ViewItem"]:
+    def from_response(cls, resp: "Response", ns, workbook_id="") -> list["ViewItem"]:
         return cls.from_xml_element(fromstring(resp), ns, workbook_id)
 
     @classmethod
-    def from_xml_element(cls, parsed_response, ns, workbook_id="") -> List["ViewItem"]:
+    def from_xml_element(cls, parsed_response, ns, workbook_id="") -> list["ViewItem"]:
         all_view_items = list()
         all_view_xml = parsed_response.findall(".//t:view", namespaces=ns)
         for view_xml in all_view_xml:

tableauserverclient/models/virtual_connection_item.py

@@ -0,0 +1,78 @@
+import datetime as dt
+import json
+from typing import Callable, Optional
+from collections.abc import Iterable
+from xml.etree.ElementTree import Element
+
+from defusedxml.ElementTree import fromstring
+
+from tableauserverclient.datetime_helpers import parse_datetime
+from tableauserverclient.models.connection_item import ConnectionItem
+from tableauserverclient.models.exceptions import UnpopulatedPropertyError
+from tableauserverclient.models.permissions_item import PermissionsRule
+
+
+class VirtualConnectionItem:
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.created_at: Optional[dt.datetime] = None
+        self.has_extracts: Optional[bool] = None
+        self._id: Optional[str] = None
+        self.is_certified: Optional[bool] = None
+        self.updated_at: Optional[dt.datetime] = None
+        self.webpage_url: Optional[str] = None
+        self._connections: Optional[Callable[[], Iterable[ConnectionItem]]] = None
+        self.project_id: Optional[str] = None
+        self.owner_id: Optional[str] = None
+        self.content: Optional[dict[str, dict]] = None
+        self.certification_note: Optional[str] = None
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__qualname__}(name={self.name})"
+
+    def __repr__(self) -> str:
+        return f"<{self!s}>"
+
+    def _set_permissions(self, permissions):
+        self._permissions = permissions
+
+    @property
+    def id(self) -> Optional[str]:
+        return self._id
+
+    @property
+    def permissions(self) -> list[PermissionsRule]:
+        if self._permissions is None:
+            error = "Workbook item must be populated with permissions first."
+            raise UnpopulatedPropertyError(error)
+        return self._permissions()
+
+    @property
+    def connections(self) -> Iterable[ConnectionItem]:
+        if self._connections is None:
+            raise AttributeError("connections not populated. Call populate_connections() first.")
+        return self._connections()
+
+    @classmethod
+    def from_response(cls, response: bytes, ns: dict[str, str]) -> list["VirtualConnectionItem"]:
+        parsed_response = fromstring(response)
+        return [cls.from_xml(xml, ns) for xml in parsed_response.findall(".//t:virtualConnection[@name]", ns)]
+
+    @classmethod
+    def from_xml(cls, xml: Element, ns: dict[str, str]) -> "VirtualConnectionItem":
+        v_conn = cls(xml.get("name", ""))
+        v_conn._id = xml.get("id", None)
+        v_conn.webpage_url = xml.get("webpageUrl", None)
+        v_conn.created_at = parse_datetime(xml.get("createdAt", None))
+        v_conn.updated_at = parse_datetime(xml.get("updatedAt", None))
+        v_conn.is_certified = string_to_bool(s) if (s := xml.get("isCertified", None)) else None
+        v_conn.certification_note = xml.get("certificationNote", None)
+        v_conn.has_extracts = string_to_bool(s) if (s := xml.get("hasExtracts", None)) else None
+        v_conn.project_id = p.get("id", None) if ((p := xml.find(".//t:project[@id]", ns)) is not None) else None
+        v_conn.owner_id = o.get("id", None) if ((o := xml.find(".//t:owner[@id]", ns)) is not None) else None
+        v_conn.content = json.loads(c.text or "{}") if ((c := xml.find(".//t:content", ns)) is not None) else None
+        return v_conn
+
+
+def string_to_bool(s: str) -> bool:
+    return s.lower() in ["true", "1", "t", "y", "yes"]

tableauserverclient/models/webhook_item.py

@@ -1,6 +1,6 @@
 import re
 import xml.etree.ElementTree as ET
-from typing import List, Optional, Tuple, Type
+from typing import Optional
 
 from defusedxml.ElementTree import fromstring
 
@@ -13,7 +13,7 @@ def _parse_event(events):
     return NAMESPACE_RE.sub("", event.tag)
 
 
-class WebhookItem(object):
+class WebhookItem:
     def __init__(self):
         self._id: Optional[str] = None
         self.name: Optional[str] = None
@@ -45,10 +45,10 @@ class WebhookItem(object):
 
     @event.setter
     def event(self, value: str) -> None:
-        self._event = "webhook-source-event-{}".format(value)
+        self._event = f"webhook-source-event-{value}"
 
     @classmethod
-    def from_response(cls: Type["WebhookItem"], resp: bytes, ns) -> List["WebhookItem"]:
+    def from_response(cls: type["WebhookItem"], resp: bytes, ns) -> list["WebhookItem"]:
         all_webhooks_items = list()
         parsed_response = fromstring(resp)
         all_webhooks_xml = parsed_response.findall(".//t:webhook", namespaces=ns)
@@ -61,7 +61,7 @@ class WebhookItem(object):
         return all_webhooks_items
 
     @staticmethod
-    def _parse_element(webhook_xml: ET.Element, ns) -> Tuple:
+    def _parse_element(webhook_xml: ET.Element, ns) -> tuple:
         id = webhook_xml.get("id", None)
         name = webhook_xml.get("name", None)
 
@@ -82,4 +82,4 @@ class WebhookItem(object):
         return id, name, url, event, owner_id
 
     def __repr__(self) -> str:
-        return "<Webhook id={} name={} url={} event={}>".format(self.id, self.name, self.url, self.event)
+        return f"<Webhook id={self.id} name={self.name} url={self.url} event={self.event}>"

tableauserverclient/models/workbook_item.py

@@ -2,7 +2,7 @@ import copy
 import datetime
 import uuid
 import xml.etree.ElementTree as ET
-from typing import Callable, Dict, List, Optional, Set
+from typing import Callable, Optional
 
 from defusedxml.ElementTree import fromstring
 
@@ -20,7 +20,85 @@ from .view_item import ViewItem
 from .data_freshness_policy_item import DataFreshnessPolicyItem
 
 
-class WorkbookItem(object):
+class WorkbookItem:
+    """
+    The workbook resources for Tableau are defined in the WorkbookItem class.
+    The class corresponds to the workbook resources you can access using the
+    Tableau REST API. Some workbook methods take an instance of the WorkbookItem
+    class as arguments. The workbook item specifies the project.
+
+    Parameters
+    ----------
+    project_id : Optional[str], optional
+        The project ID for the workbook, by default None.
+
+    name : Optional[str], optional
+        The name of the workbook, by default None.
+
+    show_tabs : bool, optional
+        Determines whether the workbook shows tabs for the view.
+
+    Attributes
+    ----------
+    connections : list[ConnectionItem]
+        The list of data connections (ConnectionItem) for the data sources used
+        by the workbook. You must first call the workbooks.populate_connections
+        method to access this data. See the ConnectionItem class.
+
+    content_url : Optional[str]
+        The name of the workbook as it appears in the URL.
+
+    created_at : Optional[datetime.datetime]
+        The date and time the workbook was created.
+
+    description : Optional[str]
+        User-defined description of the workbook.
+
+    id : Optional[str]
+       The identifier for the workbook. You need this value to query a specific
+       workbook or to delete a workbook with the get_by_id and delete methods.
+
+    owner_id : Optional[str]
+        The identifier for the owner (UserItem) of the workbook.
+
+    preview_image : bytes
+        The thumbnail image for the view. You must first call the
+        workbooks.populate_preview_image method to access this data.
+
+    project_name : Optional[str]
+        The name of the project that contains the workbook.
+
+    size: int
+        The size of the workbook in megabytes.
+
+    hidden_views: Optional[list[str]]
+        List of string names of views that need to be hidden when the workbook
+        is published.
+
+    tags: set[str]
+        The set of tags associated with the workbook.
+
+    updated_at : Optional[datetime.datetime]
+        The date and time the workbook was last updated.
+
+    views : list[ViewItem]
+        The list of views (ViewItem) for the workbook. You must first call the
+        workbooks.populate_views method to access this data. See the ViewItem
+        class.
+
+    web_page_url : Optional[str]
+        The full URL for the workbook.
+
+    Examples
+    --------
+    # creating a new instance of a WorkbookItem
+    >>> import tableauserverclient as TSC
+
+    >>> # Create new workbook_item with project id '3a8b6148-493c-11e6-a621-6f3499394a39'
+
+    >>> new_workbook = TSC.WorkbookItem('3a8b6148-493c-11e6-a621-6f3499394a39')
+    """
+
     def __init__(self, project_id: Optional[str] = None, name: Optional[str] = None, show_tabs: bool = False) -> None:
         self._connections = None
         self._content_url = None
@@ -35,15 +113,15 @@ class WorkbookItem(object):
         self._revisions = None
         self._size = None
         self._updated_at = None
-        self._views: Optional[Callable[[], List[ViewItem]]] = None
+        self._views: Optional[Callable[[], list[ViewItem]]] = None
         self.name = name
         self._description = None
         self.owner_id: Optional[str] = None
         # workaround for Personal Space workbooks without a project
         self.project_id: Optional[str] = project_id or uuid.uuid4().__str__()
         self.show_tabs = show_tabs
-        self.hidden_views: Optional[List[str]] = None
-        self.tags: Set[str] = set()
+        self.hidden_views: Optional[list[str]] = None
+        self.tags: set[str] = set()
         self.data_acceleration_config = {
             "acceleration_enabled": None,
             "accelerate_now": None,
@@ -56,7 +134,7 @@ class WorkbookItem(object):
         return None
 
     def __str__(self):
-        return "<WorkbookItem {0} '{1}' contentUrl='{2}' project={3}>".format(
+        return "<WorkbookItem {} '{}' contentUrl='{}' project={}>".format(
             self._id, self.name, self.content_url, self.project_id
         )
 
@@ -64,14 +142,14 @@ class WorkbookItem(object):
         return self.__str__() + "  { " + ", ".join(" % s: % s" % item for item in vars(self).items()) + "}"
 
     @property
-    def connections(self) -> List[ConnectionItem]:
+    def connections(self) -> list[ConnectionItem]:
         if self._connections is None:
             error = "Workbook item must be populated with connections first."
             raise UnpopulatedPropertyError(error)
         return self._connections()
 
     @property
-    def permissions(self) -> List[PermissionsRule]:
+    def permissions(self) -> list[PermissionsRule]:
         if self._permissions is None:
             error = "Workbook item must be populated with permissions first."
             raise UnpopulatedPropertyError(error)
@@ -152,7 +230,7 @@ class WorkbookItem(object):
         return self._updated_at
 
     @property
-    def views(self) -> List[ViewItem]:
+    def views(self) -> list[ViewItem]:
         # Views can be set in an initial workbook response OR by a call
         # to Server. Without getting too fancy, I think we can rely on
         # returning a list from the response, until they call
@@ -191,7 +269,7 @@ class WorkbookItem(object):
         self._data_freshness_policy = value
 
     @property
-    def revisions(self) -> List[RevisionItem]:
+    def revisions(self) -> list[RevisionItem]:
         if self._revisions is None:
             error = "Workbook item must be populated with revisions first."
             raise UnpopulatedPropertyError(error)
@@ -203,7 +281,7 @@ class WorkbookItem(object):
     def _set_permissions(self, permissions):
         self._permissions = permissions
 
-    def _set_views(self, views: Callable[[], List[ViewItem]]) -> None:
+    def _set_views(self, views: Callable[[], list[ViewItem]]) -> None:
         self._views = views
 
     def _set_pdf(self, pdf: Callable[[], bytes]) -> None:
@@ -316,7 +394,7 @@ class WorkbookItem(object):
             self.data_freshness_policy = data_freshness_policy
 
     @classmethod
-    def from_response(cls, resp: str, ns: Dict[str, str]) -> List["WorkbookItem"]:
+    def from_response(cls, resp: str, ns: dict[str, str]) -> list["WorkbookItem"]:
         all_workbook_items = list()
         parsed_response = fromstring(resp)
         all_workbook_xml = parsed_response.findall(".//t:workbook", namespaces=ns)

tableauserverclient/namespace.py

@@ -11,7 +11,7 @@ class UnknownNamespaceError(Exception):
     pass
 
 
-class Namespace(object):
+class Namespace:
     def __init__(self):
         self._namespace = {"t": NEW_NAMESPACE}
         self._detected = False

tableauserverclient/server/__init__.py

@@ -11,7 +11,7 @@ from tableauserverclient.server.filter import Filter
 from tableauserverclient.server.sort import Sort
 from tableauserverclient.server.server import Server
 from tableauserverclient.server.pager import Pager
-from tableauserverclient.server.endpoint.exceptions import NotSignedInError
+from tableauserverclient.server.endpoint.exceptions import FailedSignInError, NotSignedInError
 
 from tableauserverclient.server.endpoint import (
     Auth,
@@ -57,6 +57,7 @@ __all__ = [
     "Sort",
     "Server",
     "Pager",
+    "FailedSignInError",
     "NotSignedInError",
     "Auth",
     "CustomViews",

tableauserverclient/server/endpoint/__init__.py

@@ -12,7 +12,9 @@ from tableauserverclient.server.endpoint.flow_runs_endpoint import FlowRuns
 from tableauserverclient.server.endpoint.flows_endpoint import Flows
 from tableauserverclient.server.endpoint.flow_task_endpoint import FlowTasks
 from tableauserverclient.server.endpoint.groups_endpoint import Groups
+from tableauserverclient.server.endpoint.groupsets_endpoint import GroupSets
 from tableauserverclient.server.endpoint.jobs_endpoint import Jobs
+from tableauserverclient.server.endpoint.linked_tasks_endpoint import LinkedTasks
 from tableauserverclient.server.endpoint.metadata_endpoint import Metadata
 from tableauserverclient.server.endpoint.metrics_endpoint import Metrics
 from tableauserverclient.server.endpoint.projects_endpoint import Projects
@@ -21,9 +23,11 @@ from tableauserverclient.server.endpoint.server_info_endpoint import ServerInfo
 from tableauserverclient.server.endpoint.sites_endpoint import Sites
 from tableauserverclient.server.endpoint.subscriptions_endpoint import Subscriptions
 from tableauserverclient.server.endpoint.tables_endpoint import Tables
+from tableauserverclient.server.endpoint.resource_tagger import Tags
 from tableauserverclient.server.endpoint.tasks_endpoint import Tasks
 from tableauserverclient.server.endpoint.users_endpoint import Users
 from tableauserverclient.server.endpoint.views_endpoint import Views
+from tableauserverclient.server.endpoint.virtual_connections_endpoint import VirtualConnections
 from tableauserverclient.server.endpoint.webhooks_endpoint import Webhooks
 from tableauserverclient.server.endpoint.workbooks_endpoint import Workbooks
 
@@ -43,7 +47,9 @@ __all__ = [
     "Flows",
     "FlowTasks",
     "Groups",
+    "GroupSets",
     "Jobs",
+    "LinkedTasks",
     "Metadata",
     "Metrics",
     "Projects",
@@ -53,9 +59,11 @@ __all__ = [
     "Sites",
     "Subscriptions",
     "Tables",
+    "Tags",
     "Tasks",
     "Users",
     "Views",
+    "VirtualConnections",
     "Webhooks",
     "Workbooks",
 ]