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

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
 
@@ -45,7 +46,7 @@ class Permission:
             return "<Enum Capability: AddComment | ChangeHierarchy | ChangePermission ... (17 more) >"
 
 
-class PermissionsRule(object):
+class PermissionsRule:
     def __init__(self, grantee: ResourceReference, capabilities: Dict[str, str]) -> None:
         self.grantee = grantee
         self.capabilities = capabilities
@@ -53,6 +54,51 @@ class PermissionsRule(object):
     def __repr__(self):
         return "<PermissionsRule grantee={}, capabilities={}>".format(self.grantee, self.capabilities)
 
+    def __eq__(self, other: object) -> bool:
+        if not hasattr(other, "grantee") or not hasattr(other, "capabilities"):
+            return False
+        return self.grantee == other.grantee and self.capabilities == other.capabilities
+
+    def __and__(self, other: "PermissionsRule") -> "PermissionsRule":
+        if self.grantee != other.grantee:
+            raise ValueError("Cannot AND two permissions rules with different grantees")
+
+        if self.capabilities == other.capabilities:
+            return self
+
+        capabilities = set((*self.capabilities.keys(), *other.capabilities.keys()))
+        new_capabilities = {}
+        for capability in capabilities:
+            if (self.capabilities.get(capability), other.capabilities.get(capability)) == (
+                Permission.Mode.Allow,
+                Permission.Mode.Allow,
+            ):
+                new_capabilities[capability] = Permission.Mode.Allow
+            elif Permission.Mode.Deny in (self.capabilities.get(capability), other.capabilities.get(capability)):
+                new_capabilities[capability] = Permission.Mode.Deny
+
+        return PermissionsRule(self.grantee, new_capabilities)
+
+    def __or__(self, other: "PermissionsRule") -> "PermissionsRule":
+        if self.grantee != other.grantee:
+            raise ValueError("Cannot OR two permissions rules with different grantees")
+
+        if self.capabilities == other.capabilities:
+            return self
+
+        capabilities = set((*self.capabilities.keys(), *other.capabilities.keys()))
+        new_capabilities = {}
+        for capability in capabilities:
+            if Permission.Mode.Allow in (self.capabilities.get(capability), other.capabilities.get(capability)):
+                new_capabilities[capability] = Permission.Mode.Allow
+            elif (self.capabilities.get(capability), other.capabilities.get(capability)) == (
+                Permission.Mode.Deny,
+                Permission.Mode.Deny,
+            ):
+                new_capabilities[capability] = Permission.Mode.Deny
+
+        return PermissionsRule(self.grantee, new_capabilities)
+
     @classmethod
     def from_response(cls, resp, ns=None) -> List["PermissionsRule"]:
         parsed_response = fromstring(resp)
@@ -97,6 +143,8 @@ class PermissionsRule(object):
             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/project_item.py

@@ -4,8 +4,8 @@ from typing import List, Optional
 
 from defusedxml.ElementTree import fromstring
 
-from .exceptions import UnpopulatedPropertyError
-from .property_decorators import property_is_enum, property_not_empty
+from tableauserverclient.models.exceptions import UnpopulatedPropertyError
+from tableauserverclient.models.property_decorators import property_is_enum, property_not_empty
 
 
 class ProjectItem(object):
@@ -34,6 +34,7 @@ class ProjectItem(object):
         self.content_permissions: Optional[str] = content_permissions
         self.parent_id: Optional[str] = parent_id
         self._samples: Optional[bool] = samples
+        self._owner_id: Optional[str] = None
 
         self._permissions = None
         self._default_workbook_permissions = None
@@ -119,7 +120,7 @@ class ProjectItem(object):
 
     @owner_id.setter
     def owner_id(self, value: str) -> None:
-        raise NotImplementedError("REST API does not currently support updating project owner.")
+        self._owner_id = value
 
     def is_default(self):
         return self.name.lower() == "default"

tableauserverclient/models/reference_item.py

@@ -8,6 +8,11 @@ class ResourceReference(object):
 
     __repr__ = __str__
 
+    def __eq__(self, other: object) -> bool:
+        if not hasattr(other, "id") or not hasattr(other, "tag_name"):
+            return False
+        return (self.id == other.id) and (self.tag_name == other.tag_name)
+
     @property
     def id(self):
         return self._id

tableauserverclient/models/tableau_auth.py

@@ -1,16 +1,20 @@
 import abc
+from typing import Dict, Optional
 
 
 class Credentials(abc.ABC):
-    def __init__(self, site_id=None, user_id_to_impersonate=None):
+    def __init__(self, site_id: Optional[str] = None, user_id_to_impersonate: Optional[str] = None) -> None:
         self.site_id = site_id or ""
         self.user_id_to_impersonate = user_id_to_impersonate or None
 
     @property
     @abc.abstractmethod
-    def credentials(self):
-        credentials = "Credentials can be username/password, Personal Access Token, or JWT"
-        +"This method returns values to set as an attribute on the credentials element of the request"
+    def credentials(self) -> Dict[str, str]:
+        credentials = (
+            "Credentials can be username/password, Personal Access Token, or JWT"
+            "This method returns values to set as an attribute on the credentials element of the request"
+        )
+        return {"key": "value"}
 
     @abc.abstractmethod
     def __repr__(self):
@@ -28,10 +32,9 @@ def deprecate_site_attribute():
 
 # The traditional auth type: username/password
 class TableauAuth(Credentials):
-    def __init__(self, username, password, site=None, site_id=None, user_id_to_impersonate=None):
-        if site is not None:
-            deprecate_site_attribute()
-            site_id = site
+    def __init__(
+        self, username: str, password: str, site_id: Optional[str] = None, user_id_to_impersonate: Optional[str] = None
+    ) -> None:
         super().__init__(site_id, user_id_to_impersonate)
         if password is None:
             raise TabError("Must provide a password when using traditional authentication")
@@ -39,7 +42,7 @@ class TableauAuth(Credentials):
         self.username = username
 
     @property
-    def credentials(self):
+    def credentials(self) -> Dict[str, str]:
         return {"name": self.username, "password": self.password}
 
     def __repr__(self):
@@ -49,20 +52,16 @@ class TableauAuth(Credentials):
             uid = ""
         return f"<Credentials username={self.username} password=redacted (site={self.site_id}{uid})>"
 
-    @property
-    def site(self):
-        deprecate_site_attribute()
-        return self.site_id
-
-    @site.setter
-    def site(self, value):
-        deprecate_site_attribute()
-        self.site_id = value
-
 
 # A Tableau-generated Personal Access Token
 class PersonalAccessTokenAuth(Credentials):
-    def __init__(self, token_name, personal_access_token, site_id=None, user_id_to_impersonate=None):
+    def __init__(
+        self,
+        token_name: str,
+        personal_access_token: str,
+        site_id: Optional[str] = None,
+        user_id_to_impersonate: Optional[str] = None,
+    ) -> None:
         if personal_access_token is None or token_name is None:
             raise TabError("Must provide a token and token name when using PAT authentication")
         super().__init__(site_id=site_id, user_id_to_impersonate=user_id_to_impersonate)
@@ -70,7 +69,7 @@ class PersonalAccessTokenAuth(Credentials):
         self.personal_access_token = personal_access_token
 
     @property
-    def credentials(self):
+    def credentials(self) -> Dict[str, str]:
         return {
             "personalAccessTokenName": self.token_name,
             "personalAccessTokenSecret": self.personal_access_token,
@@ -89,14 +88,14 @@ class PersonalAccessTokenAuth(Credentials):
 
 # A standard JWT generated specifically for Tableau
 class JWTAuth(Credentials):
-    def __init__(self, jwt: str, site_id=None, user_id_to_impersonate=None):
+    def __init__(self, jwt: str, site_id: Optional[str] = None, user_id_to_impersonate: Optional[str] = None) -> None:
         if jwt is None:
             raise TabError("Must provide a JWT token when using JWT authentication")
         super().__init__(site_id, user_id_to_impersonate)
         self.jwt = jwt
 
     @property
-    def credentials(self):
+    def credentials(self) -> Dict[str, str]:
         return {"jwt": self.jwt}
 
     def __repr__(self):

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/__init__.py

@@ -1,16 +1,91 @@
 # These two imports must come first
-from .request_factory import RequestFactory
-from .request_options import (
+from tableauserverclient.server.request_factory import RequestFactory
+from tableauserverclient.server.request_options import (
     CSVRequestOptions,
     ExcelRequestOptions,
     ImageRequestOptions,
     PDFRequestOptions,
     RequestOptions,
 )
+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 .filter import Filter
-from .sort import Sort
-from .endpoint import *
-from .server import Server
-from .pager import Pager
-from .endpoint.exceptions import NotSignedInError
+from tableauserverclient.server.endpoint import (
+    Auth,
+    CustomViews,
+    DataAccelerationReport,
+    DataAlerts,
+    Databases,
+    Datasources,
+    QuerysetEndpoint,
+    MissingRequiredFieldError,
+    Endpoint,
+    Favorites,
+    Fileuploads,
+    FlowRuns,
+    Flows,
+    FlowTasks,
+    Groups,
+    Jobs,
+    Metadata,
+    Metrics,
+    Projects,
+    Schedules,
+    ServerInfo,
+    ServerResponseError,
+    Sites,
+    Subscriptions,
+    Tables,
+    Tasks,
+    Users,
+    Views,
+    Webhooks,
+    Workbooks,
+)
+
+__all__ = [
+    "RequestFactory",
+    "CSVRequestOptions",
+    "ExcelRequestOptions",
+    "ImageRequestOptions",
+    "PDFRequestOptions",
+    "RequestOptions",
+    "Filter",
+    "Sort",
+    "Server",
+    "Pager",
+    "NotSignedInError",
+    "Auth",
+    "CustomViews",
+    "DataAccelerationReport",
+    "DataAlerts",
+    "Databases",
+    "Datasources",
+    "QuerysetEndpoint",
+    "MissingRequiredFieldError",
+    "Endpoint",
+    "Favorites",
+    "Fileuploads",
+    "FlowRuns",
+    "Flows",
+    "FlowTasks",
+    "Groups",
+    "Jobs",
+    "Metadata",
+    "Metrics",
+    "Projects",
+    "Schedules",
+    "ServerInfo",
+    "ServerResponseError",
+    "Sites",
+    "Subscriptions",
+    "Tables",
+    "Tasks",
+    "Users",
+    "Views",
+    "Webhooks",
+    "Workbooks",
+]

tableauserverclient/server/endpoint/__init__.py

@@ -1,28 +1,69 @@
-from .auth_endpoint import Auth
-from .custom_views_endpoint import CustomViews
-from .data_acceleration_report_endpoint import DataAccelerationReport
-from .data_alert_endpoint import DataAlerts
-from .databases_endpoint import Databases
-from .datasources_endpoint import Datasources
-from .endpoint import Endpoint, QuerysetEndpoint
-from .exceptions import ServerResponseError, MissingRequiredFieldError
-from .favorites_endpoint import Favorites
-from .fileuploads_endpoint import Fileuploads
-from .flow_runs_endpoint import FlowRuns
-from .flows_endpoint import Flows
-from .flow_task_endpoint import FlowTasks
-from .groups_endpoint import Groups
-from .jobs_endpoint import Jobs
-from .metadata_endpoint import Metadata
-from .metrics_endpoint import Metrics
-from .projects_endpoint import Projects
-from .schedules_endpoint import Schedules
-from .server_info_endpoint import ServerInfo
-from .sites_endpoint import Sites
-from .subscriptions_endpoint import Subscriptions
-from .tables_endpoint import Tables
-from .tasks_endpoint import Tasks
-from .users_endpoint import Users
-from .views_endpoint import Views
-from .webhooks_endpoint import Webhooks
-from .workbooks_endpoint import Workbooks
+from tableauserverclient.server.endpoint.auth_endpoint import Auth
+from tableauserverclient.server.endpoint.custom_views_endpoint import CustomViews
+from tableauserverclient.server.endpoint.data_acceleration_report_endpoint import DataAccelerationReport
+from tableauserverclient.server.endpoint.data_alert_endpoint import DataAlerts
+from tableauserverclient.server.endpoint.databases_endpoint import Databases
+from tableauserverclient.server.endpoint.datasources_endpoint import Datasources
+from tableauserverclient.server.endpoint.endpoint import Endpoint, QuerysetEndpoint
+from tableauserverclient.server.endpoint.exceptions import ServerResponseError, MissingRequiredFieldError
+from tableauserverclient.server.endpoint.favorites_endpoint import Favorites
+from tableauserverclient.server.endpoint.fileuploads_endpoint import Fileuploads
+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
+from tableauserverclient.server.endpoint.schedules_endpoint import Schedules
+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
+
+__all__ = [
+    "Auth",
+    "CustomViews",
+    "DataAccelerationReport",
+    "DataAlerts",
+    "Databases",
+    "Datasources",
+    "QuerysetEndpoint",
+    "MissingRequiredFieldError",
+    "Endpoint",
+    "Favorites",
+    "Fileuploads",
+    "FlowRuns",
+    "Flows",
+    "FlowTasks",
+    "Groups",
+    "GroupSets",
+    "Jobs",
+    "LinkedTasks",
+    "Metadata",
+    "Metrics",
+    "Projects",
+    "Schedules",
+    "ServerInfo",
+    "ServerResponseError",
+    "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