tableauserverclient 0.25__py3-none-any.whl → 0.27.post0.dev1__py3-none-any.whl

tableauserverclient/models/metric_item.py

@@ -5,6 +5,7 @@ from typing import List, Optional, Set
 from tableauserverclient.datetime_helpers import parse_datetime
 from .property_decorators import property_is_boolean, property_is_datetime
 from .tag_item import TagItem
+from .permissions_item import Permission
 
 
 class MetricItem(object):
@@ -22,6 +23,7 @@ class MetricItem(object):
         self._view_id: Optional[str] = None
         self._initial_tags: Set[str] = set()
         self.tags: Set[str] = set()
+        self._permissions: Optional[Permission] = None
 
     @property
     def id(self) -> Optional[str]:
@@ -110,9 +112,15 @@ class MetricItem(object):
     def view_id(self, value: Optional[str]) -> None:
         self._view_id = value
 
-    def __repr__(self):
+    def _set_permissions(self, permissions):
+        self._permissions = permissions
+
+    def __str__(self):
         return "<MetricItem# name={_name} id={_id} owner_id={_owner_id}>".format(**vars(self))
 
+    def __repr__(self):
+        return self.__str__() + "  { " + ", ".join(" % s: % s" % item for item in vars(self).items()) + "}"
+
     @classmethod
     def from_response(
         cls,
@@ -123,36 +131,35 @@ class MetricItem(object):
         parsed_response = ET.fromstring(resp)
         all_metric_xml = parsed_response.findall(".//t:metric", namespaces=ns)
         for metric_xml in all_metric_xml:
-            metric_item = cls()
-            metric_item._id = metric_xml.get("id", None)
-            metric_item._name = metric_xml.get("name", None)
-            metric_item._description = metric_xml.get("description", None)
-            metric_item._webpage_url = metric_xml.get("webpageUrl", None)
-            metric_item._created_at = parse_datetime(metric_xml.get("createdAt", None))
-            metric_item._updated_at = parse_datetime(metric_xml.get("updatedAt", None))
-            metric_item._suspended = string_to_bool(metric_xml.get("suspended", ""))
-            for owner in metric_xml.findall(".//t:owner", namespaces=ns):
-                metric_item._owner_id = owner.get("id", None)
-
-            for project in metric_xml.findall(".//t:project", namespaces=ns):
-                metric_item._project_id = project.get("id", None)
-                metric_item._project_name = project.get("name", None)
-
-            for view in metric_xml.findall(".//t:underlyingView", namespaces=ns):
-                metric_item._view_id = view.get("id", None)
-
-            tags = set()
-            tags_elem = metric_xml.find(".//t:tags", namespaces=ns)
-            if tags_elem is not None:
-                all_tags = TagItem.from_xml_element(tags_elem, ns)
-                tags = all_tags
-
-            metric_item.tags = tags
-            metric_item._initial_tags = tags
-
-            all_metric_items.append(metric_item)
+            all_metric_items.append(cls.from_xml(metric_xml, ns))
         return all_metric_items
 
+    @classmethod
+    def from_xml(cls, metric_xml, ns):
+        metric_item = cls()
+        metric_item._id = metric_xml.get("id", None)
+        metric_item._name = metric_xml.get("name", None)
+        metric_item._description = metric_xml.get("description", None)
+        metric_item._webpage_url = metric_xml.get("webpageUrl", None)
+        metric_item._created_at = parse_datetime(metric_xml.get("createdAt", None))
+        metric_item._updated_at = parse_datetime(metric_xml.get("updatedAt", None))
+        metric_item._suspended = string_to_bool(metric_xml.get("suspended", ""))
+        for owner in metric_xml.findall(".//t:owner", namespaces=ns):
+            metric_item._owner_id = owner.get("id", None)
+        for project in metric_xml.findall(".//t:project", namespaces=ns):
+            metric_item._project_id = project.get("id", None)
+            metric_item._project_name = project.get("name", None)
+        for view in metric_xml.findall(".//t:underlyingView", namespaces=ns):
+            metric_item._view_id = view.get("id", None)
+        tags = set()
+        tags_elem = metric_xml.find(".//t:tags", namespaces=ns)
+        if tags_elem is not None:
+            all_tags = TagItem.from_xml_element(tags_elem, ns)
+            tags = all_tags
+        metric_item.tags = tags
+        metric_item._initial_tags = tags
+        return metric_item
+
 
 # Used to convert string represented boolean to a boolean type
 def string_to_bool(s: str) -> bool:

tableauserverclient/models/pagination_item.py

@@ -7,6 +7,9 @@ class PaginationItem(object):
         self._page_size = None
         self._total_available = None
 
+    def __repr__(self):
+        return f"<PaginationItem page_number={self._page_number} page_size={self._page_size} total={self._total_available}>"
+
     @property
     def page_number(self) -> int:
         return self._page_number

tableauserverclient/models/permissions_item.py

@@ -1,4 +1,3 @@
-import logging
 import xml.etree.ElementTree as ET
 from typing import Dict, List, Optional
 
@@ -9,7 +8,7 @@ from .group_item import GroupItem
 from .reference_item import ResourceReference
 from .user_item import UserItem
 
-logger = logging.getLogger("tableau.models.permissions_item")
+from tableauserverclient.helpers.logging import logger
 
 
 class Permission:
@@ -17,6 +16,9 @@ class Permission:
         Allow = "Allow"
         Deny = "Deny"
 
+        def __repr__(self):
+            return "<Enum Mode: Allow | Deny>"
+
     class Capability:
         AddComment = "AddComment"
         ChangeHierarchy = "ChangeHierarchy"
@@ -39,17 +41,18 @@ class Permission:
         CreateRefreshMetrics = "CreateRefreshMetrics"
         SaveAs = "SaveAs"
 
+        def __repr__(self):
+            return "<Enum Capability: AddComment | ChangeHierarchy | ChangePermission ... (17 more) >"
+
 
 class PermissionsRule(object):
     def __init__(self, grantee: ResourceReference, capabilities: Dict[str, str]) -> None:
         self.grantee = grantee
         self.capabilities = capabilities
 
-    def __str__(self):
+    def __repr__(self):
         return "<PermissionsRule grantee={}, capabilities={}>".format(self.grantee, self.capabilities)
 
-    __repr__ = __str__
-
     @classmethod
     def from_response(cls, resp, ns=None) -> List["PermissionsRule"]:
         parsed_response = fromstring(resp)

tableauserverclient/models/project_item.py

@@ -21,10 +21,11 @@ class ProjectItem(object):
 
     def __init__(
         self,
-        name: str,
+        name: Optional[str] = None,
         description: Optional[str] = None,
         content_permissions: Optional[str] = None,
         parent_id: Optional[str] = None,
+        samples: Optional[bool] = None,
     ) -> None:
         self._content_permissions = None
         self._id: Optional[str] = None
@@ -32,6 +33,7 @@ class ProjectItem(object):
         self.name: str = name
         self.content_permissions: Optional[str] = content_permissions
         self.parent_id: Optional[str] = parent_id
+        self._samples: Optional[bool] = samples
 
         self._permissions = None
         self._default_workbook_permissions = None
@@ -104,11 +106,10 @@ class ProjectItem(object):
         return self._id
 
     @property
-    def name(self) -> str:
+    def name(self) -> Optional[str]:
         return self._name
 
     @name.setter
-    @property_not_empty
     def name(self, value: str) -> None:
         self._name = value
 
@@ -173,19 +174,16 @@ class ProjectItem(object):
         all_project_xml = parsed_response.findall(".//t:project", namespaces=ns)
 
         for project_xml in all_project_xml:
-            (
-                id,
-                name,
-                description,
-                content_permissions,
-                parent_id,
-                owner_id,
-            ) = cls._parse_element(project_xml)
-            project_item = cls(name)
-            project_item._set_values(id, name, description, content_permissions, parent_id, owner_id)
+            project_item = cls.from_xml(project_xml)
             all_project_items.append(project_item)
         return all_project_items
 
+    @classmethod
+    def from_xml(cls, project_xml, namespace=None) -> "ProjectItem":
+        project_item = cls()
+        project_item._set_values(*cls._parse_element(project_xml))
+        return project_item
+
     @staticmethod
     def _parse_element(project_xml):
         id = project_xml.get("id", None)

tableauserverclient/models/schedule_item.py

@@ -14,8 +14,6 @@ from .interval_item import (
 )
 from .property_decorators import (
     property_is_enum,
-    property_not_nullable,
-    property_is_int,
 )
 
 Interval = Union[HourlyInterval, DailyInterval, WeeklyInterval, MonthlyInterval]
@@ -27,6 +25,7 @@ class ScheduleItem(object):
         Flow = "Flow"
         Subscription = "Subscription"
         DataAcceleration = "DataAcceleration"
+        ActiveDirectorySync = "ActiveDirectorySync"
 
     class ExecutionOrder:
         Parallel = "Parallel"
@@ -49,9 +48,12 @@ class ScheduleItem(object):
         self.priority: int = priority
         self.schedule_type: str = schedule_type
 
-    def __repr__(self):
+    def __str__(self):
         return '<Schedule#{_id} "{_name}" {interval_item}>'.format(**vars(self))
 
+    def __repr__(self):
+        return self.__str__() + "  { " + ", ".join(" % s: % s" % item for item in vars(self).items()) + "}"
+
     @property
     def created_at(self) -> Optional[datetime]:
         return self._created_at
@@ -74,11 +76,10 @@ class ScheduleItem(object):
         return self._id
 
     @property
-    def name(self) -> str:
+    def name(self) -> Optional[str]:
         return self._name
 
     @name.setter
-    @property_not_nullable
     def name(self, value: str):
         self._name = value
 
@@ -91,7 +92,6 @@ class ScheduleItem(object):
         return self._priority
 
     @priority.setter
-    @property_is_int(range=(1, 100))
     def priority(self, value: int):
         self._priority = value
 
@@ -101,7 +101,6 @@ class ScheduleItem(object):
 
     @schedule_type.setter
     @property_is_enum(Type)
-    @property_not_nullable
     def schedule_type(self, value: str):
         self._schedule_type = value
 

tableauserverclient/models/server_info_item.py

@@ -3,6 +3,7 @@ import warnings
 import xml
 
 from defusedxml.ElementTree import fromstring
+from tableauserverclient.helpers.logging import logger
 
 
 class ServerInfoItem(object):
@@ -11,7 +12,7 @@ class ServerInfoItem(object):
         self._build_number = build_number
         self._rest_api_version = rest_api_version
 
-    def __str__(self):
+    def __repr__(self):
         return (
             "ServerInfoItem: [product version: "
             + self._product_version
@@ -36,7 +37,6 @@ class ServerInfoItem(object):
 
     @classmethod
     def from_response(cls, resp, ns):
-        logger = logging.getLogger("TSC.ServerInfo")
         try:
             parsed_response = fromstring(resp)
         except xml.etree.ElementTree.ParseError as error:

tableauserverclient/models/site_item.py

@@ -39,6 +39,9 @@ class SiteItem(object):
             + ">"
         )
 
+    def __repr__(self):
+        return self.__str__() + "  { " + ", ".join(" % s: % s" % item for item in vars(self).items()) + "}"
+
     class AdminMode:
         ContentAndUsers: str = "ContentAndUsers"
         ContentOnly: str = "ContentOnly"

tableauserverclient/models/subscription_item.py

@@ -4,6 +4,7 @@ from defusedxml.ElementTree import fromstring
 
 from .property_decorators import property_is_boolean
 from .target import Target
+from tableauserverclient.models import ScheduleItem
 
 if TYPE_CHECKING:
     from .target import Target
@@ -23,6 +24,7 @@ class SubscriptionItem(object):
         self.suspended = False
         self.target = target
         self.user_id = user_id
+        self.schedule = None
 
     def __repr__(self) -> str:
         if self.id is not None:
@@ -92,9 +94,14 @@ class SubscriptionItem(object):
 
         # Schedule element
         schedule_id = None
+        schedule = None
         if schedule_element is not None:
             schedule_id = schedule_element.get("id", None)
 
+            # If schedule id is not provided, then TOL with full schedule provided
+            if schedule_id is None:
+                schedule = ScheduleItem.from_element(element, ns)
+
         # Content element
         target = None
         send_if_view_empty = None
@@ -127,6 +134,7 @@ class SubscriptionItem(object):
         sub.page_size_option = page_size_option
         sub.send_if_view_empty = send_if_view_empty
         sub.suspended = suspended
+        sub.schedule = schedule
 
         return sub
 

tableauserverclient/models/table_item.py

@@ -19,6 +19,12 @@ class TableItem(object):
         self._columns = None
         self._data_quality_warnings = None
 
+    def __str__(self):
+        return f"<{self.__class__.__name__} {self._id} {self._name} >"
+
+    def __repr__(self):
+        return self.__str__() + "  { " + ", ".join(" % s: % s" % item for item in vars(self).items()) + "}"
+
     @property
     def permissions(self):
         if self._permissions is None:

tableauserverclient/models/tableau_auth.py

@@ -1,13 +1,18 @@
-class Credentials:
+import abc
+
+
+class Credentials(abc.ABC):
     def __init__(self, site_id=None, user_id_to_impersonate=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"
 
+    @abc.abstractmethod
     def __repr__(self):
         return "All Credentials types must have a debug display that does not print secrets"
 
@@ -38,7 +43,11 @@ class TableauAuth(Credentials):
         return {"name": self.username, "password": self.password}
 
     def __repr__(self):
-        return "<Credentials username={} password={}>".format(self.username, "<redacted>")
+        if self.user_id_to_impersonate:
+            uid = f", user_id_to_impersonate=f{self.user_id_to_impersonate}"
+        else:
+            uid = ""
+        return f"<Credentials username={self.username} password=redacted (site={self.site_id}{uid})>"
 
     @property
     def site(self):
@@ -51,11 +60,12 @@ class TableauAuth(Credentials):
         self.site_id = value
 
 
+# A Tableau-generated Personal Access Token
 class PersonalAccessTokenAuth(Credentials):
-    def __init__(self, token_name, personal_access_token, site_id=None):
+    def __init__(self, token_name, personal_access_token, site_id=None, user_id_to_impersonate=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)
+        super().__init__(site_id=site_id, user_id_to_impersonate=user_id_to_impersonate)
         self.token_name = token_name
         self.personal_access_token = personal_access_token
 
@@ -67,6 +77,31 @@ class PersonalAccessTokenAuth(Credentials):
         }
 
     def __repr__(self):
-        return "<PersonalAccessToken name={} token={}>(site={})".format(
-            self.token_name, self.personal_access_token[:2] + "...", self.site_id
+        if self.user_id_to_impersonate:
+            uid = f", user_id_to_impersonate=f{self.user_id_to_impersonate}"
+        else:
+            uid = ""
+        return (
+            f"<PersonalAccessToken name={self.token_name} token={self.personal_access_token[:2]}..."
+            f"(site={self.site_id}{uid} >"
         )
+
+
+# A standard JWT generated specifically for Tableau
+class JWTAuth(Credentials):
+    def __init__(self, jwt: str, site_id=None, user_id_to_impersonate=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):
+        return {"jwt": self.jwt}
+
+    def __repr__(self):
+        if self.user_id_to_impersonate:
+            uid = f", user_id_to_impersonate=f{self.user_id_to_impersonate}"
+        else:
+            uid = ""
+        return f"<{self.__class__.__qualname__} jwt={self.jwt[:5]}... (site={self.site_id}{uid})>"

tableauserverclient/models/tableau_types.py

@@ -5,23 +5,25 @@ 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
 
 
 class Resource:
     Database = "database"
     Datarole = "datarole"
+    Table = "table"
     Datasource = "datasource"
     Flow = "flow"
     Lens = "lens"
     Metric = "metric"
     Project = "project"
-    Table = "table"
     View = "view"
     Workbook = "workbook"
 
 
 # resource types that have permissions, can be renamed, etc
-TableauItem = Union[DatasourceItem, FlowItem, ProjectItem, ViewItem, WorkbookItem]
+# todo: refactoring: should actually define TableauItem as an interface and let all these implement it
+TableauItem = Union[DatasourceItem, FlowItem, MetricItem, ProjectItem, ViewItem, WorkbookItem]
 
 
 def plural_type(content_type: Resource) -> str:

tableauserverclient/models/user_item.py

@@ -45,6 +45,7 @@ class UserItem(object):
     class Auth:
         OpenID = "OpenID"
         SAML = "SAML"
+        TableauIDWithMFA = "TableauIDWithMFA"
         ServerDefault = "ServerDefault"
 
     def __init__(
@@ -66,10 +67,13 @@ class UserItem(object):
 
         return None
 
-    def __repr__(self) -> str:
+    def __str__(self) -> str:
         str_site_role = self.site_role or "None"
         return "<User {} name={} role={}>".format(self.id, self.name, str_site_role)
 
+    def __repr__(self):
+        return self.__str__() + "  { " + ", ".join(" % s: % s" % item for item in vars(self).items()) + "}"
+
     @property
     def auth_setting(self) -> Optional[str]:
         return self._auth_setting

tableauserverclient/models/view_item.py

@@ -1,5 +1,6 @@
 import copy
 from datetime import datetime
+from requests import Response
 from typing import Callable, Iterator, List, Optional, Set
 
 from defusedxml.ElementTree import fromstring
@@ -31,11 +32,14 @@ class ViewItem(object):
         self._permissions: Optional[Callable[[], List[PermissionsRule]]] = None
         self.tags: Set[str] = set()
 
-    def __repr__(self):
+    def __str__(self):
         return "<ViewItem {0} '{1}' contentUrl='{2}' project={3}>".format(
             self._id, self.name, self.content_url, self.project_id
         )
 
+    def __repr__(self):
+        return self.__str__() + "  { " + ", ".join(" % s: % s" % item for item in vars(self).items()) + "}"
+
     def _set_preview_image(self, preview_image):
         self._preview_image = preview_image
 
@@ -140,7 +144,7 @@ class ViewItem(object):
         self._permissions = permissions
 
     @classmethod
-    def from_response(cls, resp, 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
@@ -148,39 +152,38 @@ class ViewItem(object):
         all_view_items = list()
         all_view_xml = parsed_response.findall(".//t:view", namespaces=ns)
         for view_xml in all_view_xml:
-            view_item = cls()
-            usage_elem = view_xml.find(".//t:usage", namespaces=ns)
-            workbook_elem = view_xml.find(".//t:workbook", namespaces=ns)
-            owner_elem = view_xml.find(".//t:owner", namespaces=ns)
-            project_elem = view_xml.find(".//t:project", namespaces=ns)
-            tags_elem = view_xml.find(".//t:tags", namespaces=ns)
-            view_item._created_at = parse_datetime(view_xml.get("createdAt", None))
-            view_item._updated_at = parse_datetime(view_xml.get("updatedAt", None))
-            view_item._id = view_xml.get("id", None)
-            view_item._name = view_xml.get("name", None)
-            view_item._content_url = view_xml.get("contentUrl", None)
-            view_item._sheet_type = view_xml.get("sheetType", None)
-
-            if usage_elem is not None:
-                total_view = usage_elem.get("totalViewCount", None)
-                if total_view:
-                    view_item._total_views = int(total_view)
-
-            if owner_elem is not None:
-                view_item._owner_id = owner_elem.get("id", None)
-
-            if project_elem is not None:
-                view_item._project_id = project_elem.get("id", None)
-
-            if workbook_id:
-                view_item._workbook_id = workbook_id
-            elif workbook_elem is not None:
-                view_item._workbook_id = workbook_elem.get("id", None)
-
-            if tags_elem is not None:
-                tags = TagItem.from_xml_element(tags_elem, ns)
-                view_item.tags = tags
-                view_item._initial_tags = copy.copy(tags)
-
+            view_item = cls.from_xml(view_xml, ns, workbook_id)
             all_view_items.append(view_item)
         return all_view_items
+
+    @classmethod
+    def from_xml(cls, view_xml, ns, workbook_id="") -> "ViewItem":
+        view_item = cls()
+        usage_elem = view_xml.find(".//t:usage", namespaces=ns)
+        workbook_elem = view_xml.find(".//t:workbook", namespaces=ns)
+        owner_elem = view_xml.find(".//t:owner", namespaces=ns)
+        project_elem = view_xml.find(".//t:project", namespaces=ns)
+        tags_elem = view_xml.find(".//t:tags", namespaces=ns)
+        view_item._created_at = parse_datetime(view_xml.get("createdAt", None))
+        view_item._updated_at = parse_datetime(view_xml.get("updatedAt", None))
+        view_item._id = view_xml.get("id", None)
+        view_item._name = view_xml.get("name", None)
+        view_item._content_url = view_xml.get("contentUrl", None)
+        view_item._sheet_type = view_xml.get("sheetType", None)
+        if usage_elem is not None:
+            total_view = usage_elem.get("totalViewCount", None)
+            if total_view:
+                view_item._total_views = int(total_view)
+        if owner_elem is not None:
+            view_item._owner_id = owner_elem.get("id", None)
+        if project_elem is not None:
+            view_item._project_id = project_elem.get("id", None)
+        if workbook_id:
+            view_item._workbook_id = workbook_id
+        elif workbook_elem is not None:
+            view_item._workbook_id = workbook_elem.get("id", None)
+        if tags_elem is not None:
+            tags = TagItem.from_xml_element(tags_elem, ns)
+            view_item.tags = tags
+            view_item._initial_tags = copy.copy(tags)
+        return view_item