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

tableauserverclient/__init__.py

@@ -17,10 +17,14 @@ from tableauserverclient.models import (
     FlowRunItem,
     FileuploadItem,
     GroupItem,
+    GroupSetItem,
     HourlyInterval,
     IntervalItem,
     JobItem,
     JWTAuth,
+    LinkedTaskItem,
+    LinkedTaskStepItem,
+    LinkedTaskFlowRunItem,
     MetricItem,
     MonthlyInterval,
     PaginationItem,
@@ -39,6 +43,7 @@ from tableauserverclient.models import (
     TaskItem,
     UserItem,
     ViewItem,
+    VirtualConnectionItem,
     WebhookItem,
     WeeklyInterval,
     WorkbookItem,
@@ -79,6 +84,7 @@ __all__ = [
     "FlowRunItem",
     "FileuploadItem",
     "GroupItem",
+    "GroupSetItem",
     "HourlyInterval",
     "IntervalItem",
     "JobItem",
@@ -116,4 +122,8 @@ __all__ = [
     "Pager",
     "Server",
     "Sort",
+    "LinkedTaskItem",
+    "LinkedTaskStepItem",
+    "LinkedTaskFlowRunItem",
+    "VirtualConnectionItem",
 ]

tableauserverclient/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-07-27T15:44:04-0700",
+ "date": "2024-09-17T16:51:07-0700",
  "dirty": false,
  "error": null,
- "full-revisionid": "257cf616f35cc36b24a73e9e102886a52ead1853",
- "version": "0.32"
+ "full-revisionid": "4259316ef2e2656531b0c65c71d043708b37b4a9",
+ "version": "0.33"
 }
 '''  # END VERSION_JSON
 

tableauserverclient/config.py

@@ -1,13 +1,25 @@
-# TODO: check for env variables, else set default values
+import os
 
 ALLOWED_FILE_EXTENSIONS = ["tds", "tdsx", "tde", "hyper", "parquet"]
 
 BYTES_PER_MB = 1024 * 1024
 
-# For when a datasource is over 64MB, break it into 5MB(standard chunk size) chunks
-CHUNK_SIZE_MB = 5 * 10  # 5MB felt too slow, upped it to 50
-
 DELAY_SLEEP_SECONDS = 0.1
 
 # The maximum size of a file that can be published in a single request is 64MB
 FILESIZE_LIMIT_MB = 64
+
+
+class Config:
+    # For when a datasource is over 64MB, break it into 5MB(standard chunk size) chunks
+    @property
+    def CHUNK_SIZE_MB(self):
+        return int(os.getenv("TSC_CHUNK_SIZE_MB", 5 * 10))  # 5MB felt too slow, upped it to 50
+
+    # Default page size
+    @property
+    def PAGE_SIZE(self):
+        return int(os.getenv("TSC_PAGE_SIZE", 100))
+
+
+config = Config()

tableauserverclient/models/__init__.py

@@ -14,6 +14,7 @@ from tableauserverclient.models.fileupload_item import FileuploadItem
 from tableauserverclient.models.flow_item import FlowItem
 from tableauserverclient.models.flow_run_item import FlowRunItem
 from tableauserverclient.models.group_item import GroupItem
+from tableauserverclient.models.groupset_item import GroupSetItem
 from tableauserverclient.models.interval_item import (
     IntervalItem,
     DailyInterval,
@@ -22,6 +23,11 @@ from tableauserverclient.models.interval_item import (
     HourlyInterval,
 )
 from tableauserverclient.models.job_item import JobItem, BackgroundJobItem
+from tableauserverclient.models.linked_tasks_item import (
+    LinkedTaskItem,
+    LinkedTaskStepItem,
+    LinkedTaskFlowRunItem,
+)
 from tableauserverclient.models.metric_item import MetricItem
 from tableauserverclient.models.pagination_item import PaginationItem
 from tableauserverclient.models.permissions_item import PermissionsRule, Permission
@@ -39,6 +45,7 @@ from tableauserverclient.models.target import Target
 from tableauserverclient.models.task_item import TaskItem
 from tableauserverclient.models.user_item import UserItem
 from tableauserverclient.models.view_item import ViewItem
+from tableauserverclient.models.virtual_connection_item import VirtualConnectionItem
 from tableauserverclient.models.webhook_item import WebhookItem
 from tableauserverclient.models.workbook_item import WorkbookItem
 
@@ -60,6 +67,7 @@ __all__ = [
     "FlowItem",
     "FlowRunItem",
     "GroupItem",
+    "GroupSetItem",
     "IntervalItem",
     "JobItem",
     "DailyInterval",
@@ -89,6 +97,10 @@ __all__ = [
     "TaskItem",
     "UserItem",
     "ViewItem",
+    "VirtualConnectionItem",
     "WebhookItem",
     "WorkbookItem",
+    "LinkedTaskItem",
+    "LinkedTaskStepItem",
+    "LinkedTaskFlowRunItem",
 ]

tableauserverclient/models/connection_item.py

@@ -66,12 +66,14 @@ class ConnectionItem(object):
         for connection_xml in all_connection_xml:
             connection_item = cls()
             connection_item._id = connection_xml.get("id", None)
-            connection_item._connection_type = connection_xml.get("type", None)
+            connection_item._connection_type = connection_xml.get("type", connection_xml.get("dbClass", None))
             connection_item.embed_password = string_to_bool(connection_xml.get("embedPassword", ""))
             connection_item.server_address = connection_xml.get("serverAddress", None)
             connection_item.server_port = connection_xml.get("serverPort", None)
             connection_item.username = connection_xml.get("userName", None)
-            connection_item._query_tagging = string_to_bool(connection_xml.get("queryTaggingEnabled", None))
+            connection_item._query_tagging = (
+                string_to_bool(s) if (s := connection_xml.get("queryTagging", None)) else None
+            )
             datasource_elem = connection_xml.find(".//t:datasource", namespaces=ns)
             if datasource_elem is not None:
                 connection_item._datasource_id = datasource_elem.get("id", None)

tableauserverclient/models/database_item.py

@@ -44,6 +44,12 @@ class DatabaseItem(object):
 
         self._tables = None  # Not implemented yet
 
+    def __str__(self):
+        return "<Database {0} '{1}'>".format(self._id, self.name)
+
+    def __repr__(self):
+        return self.__str__() + "  { " + ", ".join(" % s: % s" % item for item in vars(self).items()) + "}"
+
     @property
     def dqws(self):
         if self._data_quality_warnings is None:

tableauserverclient/models/flow_item.py

@@ -6,12 +6,12 @@ from typing import List, Optional, Set
 from defusedxml.ElementTree import fromstring
 
 from tableauserverclient.datetime_helpers import parse_datetime
-from .connection_item import ConnectionItem
-from .dqw_item import DQWItem
-from .exceptions import UnpopulatedPropertyError
-from .permissions_item import Permission
-from .property_decorators import property_not_nullable
-from .tag_item import TagItem
+from tableauserverclient.models.connection_item import ConnectionItem
+from tableauserverclient.models.dqw_item import DQWItem
+from tableauserverclient.models.exceptions import UnpopulatedPropertyError
+from tableauserverclient.models.permissions_item import Permission
+from tableauserverclient.models.property_decorators import property_not_nullable
+from tableauserverclient.models.tag_item import TagItem
 
 
 class FlowItem(object):

tableauserverclient/models/groupset_item.py

@@ -0,0 +1,53 @@
+from typing import Dict, List, Optional
+import xml.etree.ElementTree as ET
+
+from defusedxml.ElementTree import fromstring
+
+from tableauserverclient.models.group_item import GroupItem
+from tableauserverclient.models.reference_item import ResourceReference
+
+
+class GroupSetItem:
+    tag_name: str = "groupSet"
+
+    def __init__(self, name: Optional[str] = None) -> None:
+        self.name = name
+        self.id: Optional[str] = None
+        self.groups: List["GroupItem"] = []
+        self.group_count: int = 0
+
+    def __str__(self) -> str:
+        name = self.name
+        id = self.id
+        return f"<{self.__class__.__qualname__}({name=}, {id=})>"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    @classmethod
+    def from_response(cls, response: bytes, ns: Dict[str, str]) -> List["GroupSetItem"]:
+        parsed_response = fromstring(response)
+        all_groupset_xml = parsed_response.findall(".//t:groupSet", namespaces=ns)
+        return [cls.from_xml(xml, ns) for xml in all_groupset_xml]
+
+    @classmethod
+    def from_xml(cls, groupset_xml: ET.Element, ns: Dict[str, str]) -> "GroupSetItem":
+        def get_group(group_xml: ET.Element) -> GroupItem:
+            group_item = GroupItem()
+            group_item._id = group_xml.get("id")
+            group_item.name = group_xml.get("name")
+            return group_item
+
+        group_set_item = cls()
+        group_set_item.name = groupset_xml.get("name")
+        group_set_item.id = groupset_xml.get("id")
+        group_set_item.group_count = int(count) if (count := groupset_xml.get("groupCount")) else 0
+        group_set_item.groups = [
+            get_group(group_xml) for group_xml in groupset_xml.findall(".//t:group", namespaces=ns)
+        ]
+
+        return group_set_item
+
+    @staticmethod
+    def as_reference(id_: str) -> ResourceReference:
+        return ResourceReference(id_, GroupSetItem.tag_name)

tableauserverclient/models/interval_item.py

@@ -246,21 +246,34 @@ class MonthlyInterval(object):
 
     @interval.setter
     def interval(self, interval_values):
-        # This is weird because the value could be a str or an int
-        # The only valid str is 'LastDay' so we check that first. If that's not it
-        # try to convert it to an int, if that fails because it's an incorrect string
-        # like 'badstring' we catch and re-raise. Otherwise we convert to int and check
-        # that it's in range 1-31
+        # Valid monthly intervals strings can contain any of the following
+        #   day numbers (1-31) (integer or string)
+        #   relative day within the month (First, Second, ... Last)
+        #   week days (Sunday, Monday, ... LastDay)
+        VALID_INTERVALS = [
+            "Sunday",
+            "Monday",
+            "Tuesday",
+            "Wednesday",
+            "Thursday",
+            "Friday",
+            "Saturday",
+            "LastDay",
+            "First",
+            "Second",
+            "Third",
+            "Fourth",
+            "Fifth",
+            "Last",
+        ]
+        for value in range(1, 32):
+            VALID_INTERVALS.append(str(value))
+            VALID_INTERVALS.append(value)
+
         for interval_value in interval_values:
-            error = "Invalid interval value for a monthly frequency: {}.".format(interval_value)
-
-            if interval_value != "LastDay":
-                try:
-                    if not (1 <= int(interval_value) <= 31):
-                        raise ValueError(error)
-                except ValueError:
-                    if interval_value != "LastDay":
-                        raise ValueError(error)
+            if interval_value not in VALID_INTERVALS:
+                error = f"Invalid monthly interval: {interval_value}"
+                raise ValueError(error)
 
         self._interval = interval_values
 

tableauserverclient/models/job_item.py

@@ -4,7 +4,7 @@ from typing import List, Optional
 from defusedxml.ElementTree import fromstring
 
 from tableauserverclient.datetime_helpers import parse_datetime
-from .flow_run_item import FlowRunItem
+from tableauserverclient.models.flow_run_item import FlowRunItem
 
 
 class JobItem(object):
@@ -33,6 +33,8 @@ class JobItem(object):
         datasource_id: Optional[str] = None,
         flow_run: Optional[FlowRunItem] = None,
         updated_at: Optional[datetime.datetime] = None,
+        workbook_name: Optional[str] = None,
+        datasource_name: Optional[str] = None,
     ):
         self._id = id_
         self._type = job_type
@@ -47,6 +49,8 @@ class JobItem(object):
         self._datasource_id = datasource_id
         self._flow_run = flow_run
         self._updated_at = updated_at
+        self._workbook_name = workbook_name
+        self._datasource_name = datasource_name
 
     @property
     def id(self) -> str:
@@ -117,6 +121,14 @@ class JobItem(object):
     def updated_at(self) -> Optional[datetime.datetime]:
         return self._updated_at
 
+    @property
+    def workbook_name(self) -> Optional[str]:
+        return self._workbook_name
+
+    @property
+    def datasource_name(self) -> Optional[str]:
+        return self._datasource_name
+
     def __str__(self):
         return (
             "<Job#{_id} {_type} created_at({_created_at}) started_at({_started_at}) updated_at({_updated_at}) completed_at({_completed_at})"
@@ -148,8 +160,10 @@ class JobItem(object):
         mode = element.get("mode", None)
         workbook = element.find(".//t:workbook[@id]", namespaces=ns)
         workbook_id = workbook.get("id") if workbook is not None else None
+        workbook_name = workbook.get("name") if workbook is not None else None
         datasource = element.find(".//t:datasource[@id]", namespaces=ns)
         datasource_id = datasource.get("id") if datasource is not None else None
+        datasource_name = datasource.get("name") if datasource is not None else None
         flow_run = None
         updated_at = parse_datetime(element.get("updatedAt", None))
         for flow_job in element.findall(".//t:runFlowJobType", namespaces=ns):
@@ -172,6 +186,8 @@ class JobItem(object):
             datasource_id,
             flow_run,
             updated_at,
+            workbook_name,
+            datasource_name,
         )
 
 
@@ -206,7 +222,7 @@ class BackgroundJobItem(object):
         self._subtitle = subtitle
 
     def __str__(self):
-        return f"<{self.__class__.name} {self._id} {self._type}>"
+        return f"<{self.__class__.__qualname__} {self._id} {self._type}>"
 
     def __repr__(self):
         return self.__str__() + "  { " + ", ".join(" % s: % s" % item for item in vars(self).items()) + "}"

tableauserverclient/models/linked_tasks_item.py

@@ -0,0 +1,102 @@
+import datetime as dt
+from typing import List, Optional
+
+from defusedxml.ElementTree import fromstring
+
+from tableauserverclient.datetime_helpers import parse_datetime
+from tableauserverclient.models.schedule_item import ScheduleItem
+
+
+class LinkedTaskItem:
+    def __init__(self) -> None:
+        self.id: Optional[str] = None
+        self.num_steps: Optional[int] = None
+        self.schedule: Optional[ScheduleItem] = None
+
+    @classmethod
+    def from_response(cls, resp: bytes, namespace) -> List["LinkedTaskItem"]:
+        parsed_response = fromstring(resp)
+        return [
+            cls._parse_element(x, namespace)
+            for x in parsed_response.findall(".//t:linkedTasks[@id]", namespaces=namespace)
+        ]
+
+    @classmethod
+    def _parse_element(cls, xml, namespace) -> "LinkedTaskItem":
+        task = cls()
+        task.id = xml.get("id")
+        task.num_steps = int(xml.get("numSteps"))
+        task.schedule = ScheduleItem.from_element(xml, namespace)[0]
+        return task
+
+
+class LinkedTaskStepItem:
+    def __init__(self) -> None:
+        self.id: Optional[str] = None
+        self.step_number: Optional[int] = None
+        self.stop_downstream_on_failure: Optional[bool] = None
+        self.task_details: List[LinkedTaskFlowRunItem] = []
+
+    @classmethod
+    def from_task_xml(cls, xml, namespace) -> List["LinkedTaskStepItem"]:
+        return [cls._parse_element(x, namespace) for x in xml.findall(".//t:linkedTaskSteps[@id]", namespace)]
+
+    @classmethod
+    def _parse_element(cls, xml, namespace) -> "LinkedTaskStepItem":
+        step = cls()
+        step.id = xml.get("id")
+        step.step_number = int(xml.get("stepNumber"))
+        step.stop_downstream_on_failure = string_to_bool(xml.get("stopDownstreamTasksOnFailure"))
+        step.task_details = LinkedTaskFlowRunItem._parse_element(xml, namespace)
+        return step
+
+
+class LinkedTaskFlowRunItem:
+    def __init__(self) -> None:
+        self.flow_run_id: Optional[str] = None
+        self.flow_run_priority: Optional[int] = None
+        self.flow_run_consecutive_failed_count: Optional[int] = None
+        self.flow_run_task_type: Optional[str] = None
+        self.flow_id: Optional[str] = None
+        self.flow_name: Optional[str] = None
+
+    @classmethod
+    def _parse_element(cls, xml, namespace) -> List["LinkedTaskFlowRunItem"]:
+        all_tasks = []
+        for flow_run in xml.findall(".//t:flowRun[@id]", namespace):
+            task = cls()
+            task.flow_run_id = flow_run.get("id")
+            task.flow_run_priority = int(flow_run.get("priority"))
+            task.flow_run_consecutive_failed_count = int(flow_run.get("consecutiveFailedCount"))
+            task.flow_run_task_type = flow_run.get("type")
+            flow = flow_run.find(".//t:flow[@id]", namespace)
+            task.flow_id = flow.get("id")
+            task.flow_name = flow.get("name")
+            all_tasks.append(task)
+
+        return all_tasks
+
+
+class LinkedTaskJobItem:
+    def __init__(self) -> None:
+        self.id: Optional[str] = None
+        self.linked_task_id: Optional[str] = None
+        self.status: Optional[str] = None
+        self.created_at: Optional[dt.datetime] = None
+
+    @classmethod
+    def from_response(cls, resp: bytes, namespace) -> "LinkedTaskJobItem":
+        parsed_response = fromstring(resp)
+        job = cls()
+        job_xml = parsed_response.find(".//t:linkedTaskJob[@id]", namespaces=namespace)
+        if job_xml is None:
+            raise ValueError("No linked task job found in response")
+        job.id = job_xml.get("id")
+        job.linked_task_id = job_xml.get("linkedTaskId")
+        job.status = job_xml.get("status")
+        job.created_at = parse_datetime(job_xml.get("createdAt"))
+        return job
+
+
+def string_to_bool(s: str) -> bool:
+    return s.lower() == "true"

tableauserverclient/models/permissions_item.py

@@ -3,10 +3,11 @@ from typing import Dict, List, Optional
 
 from defusedxml.ElementTree import fromstring
 
-from .exceptions import UnknownGranteeTypeError, UnpopulatedPropertyError
-from .group_item import GroupItem
-from .reference_item import ResourceReference
-from .user_item import UserItem
+from tableauserverclient.models.exceptions import UnknownGranteeTypeError, UnpopulatedPropertyError
+from tableauserverclient.models.group_item import GroupItem
+from tableauserverclient.models.groupset_item import GroupSetItem
+from tableauserverclient.models.reference_item import ResourceReference
+from tableauserverclient.models.user_item import UserItem
 
 from tableauserverclient.helpers.logging import logger
 
@@ -142,6 +143,8 @@ class PermissionsRule:
             grantee = UserItem.as_reference(grantee_id)
         elif grantee_type == "group":
             grantee = GroupItem.as_reference(grantee_id)
+        elif grantee_type == "groupSet":
+            grantee = GroupSetItem.as_reference(grantee_id)
         else:
             raise UnknownGranteeTypeError("No support for grantee type of {}".format(grantee_type))
 

tableauserverclient/models/tableau_types.py

@@ -1,11 +1,12 @@
 from typing import Union
 
-from .datasource_item import DatasourceItem
-from .flow_item import FlowItem
-from .project_item import ProjectItem
-from .view_item import ViewItem
-from .workbook_item import WorkbookItem
-from .metric_item import MetricItem
+from tableauserverclient.models.datasource_item import DatasourceItem
+from tableauserverclient.models.flow_item import FlowItem
+from tableauserverclient.models.project_item import ProjectItem
+from tableauserverclient.models.view_item import ViewItem
+from tableauserverclient.models.workbook_item import WorkbookItem
+from tableauserverclient.models.metric_item import MetricItem
+from tableauserverclient.models.virtual_connection_item import VirtualConnectionItem
 
 
 class Resource:
@@ -18,12 +19,13 @@ class Resource:
     Metric = "metric"
     Project = "project"
     View = "view"
+    VirtualConnection = "virtualConnection"
     Workbook = "workbook"
 
 
 # resource types that have permissions, can be renamed, etc
 # todo: refactoring: should actually define TableauItem as an interface and let all these implement it
-TableauItem = Union[DatasourceItem, FlowItem, MetricItem, ProjectItem, ViewItem, WorkbookItem]
+TableauItem = Union[DatasourceItem, FlowItem, MetricItem, ProjectItem, ViewItem, WorkbookItem, VirtualConnectionItem]
 
 
 def plural_type(content_type: Resource) -> str:

tableauserverclient/models/virtual_connection_item.py

@@ -0,0 +1,77 @@
+import datetime as dt
+import json
+from typing import Callable, Dict, Iterable, List, Optional
+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/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",
 ]

tableauserverclient/server/endpoint/auth_endpoint.py

@@ -4,9 +4,9 @@ import warnings
 
 from defusedxml.ElementTree import fromstring
 
-from .endpoint import Endpoint, api
-from .exceptions import ServerResponseError
-from ..request_factory import RequestFactory
+from tableauserverclient.server.endpoint.endpoint import Endpoint, api
+from tableauserverclient.server.endpoint.exceptions import ServerResponseError
+from tableauserverclient.server.request_factory import RequestFactory
 
 from tableauserverclient.helpers.logging import logger