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

tableauserverclient/__init__.py

@@ -1,6 +1,47 @@
 from ._version import get_versions
 from .namespace import NEW_NAMESPACE as DEFAULT_NAMESPACE
-from .models import *
+from .models import (
+    BackgroundJobItem,
+    ColumnItem,
+    ConnectionCredentials,
+    ConnectionItem,
+    CustomViewItem,
+    DQWItem,
+    DailyInterval,
+    DataAlertItem,
+    DatabaseItem,
+    DatasourceItem,
+    FavoriteItem,
+    FlowItem,
+    FlowRunItem,
+    FileuploadItem,
+    GroupItem,
+    HourlyInterval,
+    IntervalItem,
+    JobItem,
+    JWTAuth,
+    MetricItem,
+    MonthlyInterval,
+    PaginationItem,
+    Permission,
+    PermissionsRule,
+    PersonalAccessTokenAuth,
+    ProjectItem,
+    RevisionItem,
+    ScheduleItem,
+    SiteItem,
+    ServerInfoItem,
+    SubscriptionItem,
+    TableItem,
+    TableauAuth,
+    Target,
+    TaskItem,
+    UserItem,
+    ViewItem,
+    WebhookItem,
+    WeeklyInterval,
+    WorkbookItem,
+)
 from .server import (
     CSVRequestOptions,
     ExcelRequestOptions,

tableauserverclient/_version.py

@@ -1,5 +1,5 @@
 
-# This file was generated by 'versioneer.py' (0.28) from
+# This file was generated by 'versioneer.py' (0.29) from
 # revision-control system data, or from the parent directory name of an
 # unpacked source archive. Distribution tarballs contain a pre-generated copy
 # of this file.
@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2023-03-16T11:05:21-0700",
+ "date": "2023-10-04T00:33:03-0700",
  "dirty": false,
  "error": null,
- "full-revisionid": "e4fbe41560fbd2314c9c7b8b8a169164dd15185f",
- "version": "0.25"
+ "full-revisionid": "72eb3c8500193e4f20defa20c8a6f8bbf34b2f43",
+ "version": "0.27.post0.dev1"
 }
 '''  # END VERSION_JSON
 

tableauserverclient/config.py

@@ -0,0 +1,13 @@
+# TODO: check for env variables, else set default values
+
+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 = 10
+
+# The maximum size of a file that can be published in a single request is 64MB
+FILESIZE_LIMIT_MB = 64

tableauserverclient/datetime_helpers.py

@@ -5,6 +5,10 @@ ZERO = datetime.timedelta(0)
 HOUR = datetime.timedelta(hours=1)
 
 
+def timestamp():
+    return datetime.datetime.now().strftime("%H:%M:%S")
+
+
 # This class is a concrete implementation of the abstract base class tzinfo
 # docs: https://docs.python.org/2.3/lib/datetime-tzinfo.html
 class UTC(datetime.tzinfo):

tableauserverclient/helpers/logging.py

@@ -0,0 +1,4 @@
+import logging
+
+# TODO change: this defaults to logging *everything* to stdout
+logger = logging.getLogger("TSC")

tableauserverclient/models/__init__.py

@@ -31,7 +31,7 @@ from .server_info_item import ServerInfoItem
 from .site_item import SiteItem
 from .subscription_item import SubscriptionItem
 from .table_item import TableItem
-from .tableau_auth import Credentials, TableauAuth, PersonalAccessTokenAuth
+from .tableau_auth import Credentials, TableauAuth, PersonalAccessTokenAuth, JWTAuth
 from .tableau_types import Resource, TableauItem, plural_type
 from .tag_item import TagItem
 from .target import Target

tableauserverclient/models/column_item.py

@@ -9,6 +9,9 @@ class ColumnItem(object):
         self.description = description
         self.name = name
 
+    def __repr__(self):
+        return f"<{self.__class__.__name__} {self._id} {self.name} {self.description}>"
+
     @property
     def id(self):
         return self._id

tableauserverclient/models/connection_credentials.py

@@ -15,6 +15,13 @@ class ConnectionCredentials(object):
         self.embed = embed
         self.oauth = oauth
 
+    def __repr__(self):
+        if self.password:
+            print = "redacted"
+        else:
+            print = "None"
+        return f"<{self.__class__.__name__} name={self.name} password={print} embed={self.embed} oauth={self.oauth} >"
+
     @property
     def embed(self):
         return self._embed

tableauserverclient/models/connection_item.py

@@ -5,6 +5,7 @@ from defusedxml.ElementTree import fromstring
 
 from .connection_credentials import ConnectionCredentials
 from .property_decorators import property_is_boolean
+from tableauserverclient.helpers.logging import logger
 
 
 class ConnectionItem(object):
@@ -46,7 +47,6 @@ class ConnectionItem(object):
     def query_tagging(self, value: Optional[bool]):
         # if connection type = hyper, Snowflake, or Teradata, we can't change this value: it is always true
         if self._connection_type in ["hyper", "snowflake", "teradata"]:
-            logger = logging.getLogger("tableauserverclient.models.connection_item")
             logger.debug(
                 "Cannot update value: Query tagging is always enabled for {} connections".format(self._connection_type)
             )

tableauserverclient/models/custom_view_item.py

@@ -134,6 +134,7 @@ class CustomViewItem(object):
             cv_item._content_url = custom_view_xml.get("contentUrl", None)
             cv_item._id = custom_view_xml.get("id", None)
             cv_item._name = custom_view_xml.get("name", None)
+            cv_item._shared = string_to_bool(custom_view_xml.get("shared", None))
 
             if owner_elem is not None:
                 parsed_owners = UserItem.from_response_as_owner(tostring(custom_view_xml), ns)
@@ -154,3 +155,7 @@ class CustomViewItem(object):
 
             all_view_items.append(cv_item)
         return all_view_items
+
+
+def string_to_bool(s: Optional[str]) -> bool:
+    return (s or "").lower() == "true"

tableauserverclient/models/data_acceleration_report_item.py

@@ -46,6 +46,9 @@ class DataAccelerationReportItem(object):
     def __init__(self, comparison_records):
         self._comparison_records = comparison_records
 
+    def __repr__(self):
+        return f"<(deprecated)DataAccelerationReportItem site={self.site} sheet={sheet_uri}>"
+
     @property
     def comparison_records(self):
         return self._comparison_records

tableauserverclient/models/datasource_item.py

@@ -32,7 +32,7 @@ class DatasourceItem(object):
             self.project_id,
         )
 
-    def __init__(self, project_id: str, name: Optional[str] = None) -> None:
+    def __init__(self, project_id: Optional[str] = None, name: Optional[str] = None) -> None:
         self._ask_data_enablement = None
         self._certified = None
         self._certification_note = None
@@ -135,12 +135,11 @@ class DatasourceItem(object):
         return self._id
 
     @property
-    def project_id(self) -> str:
+    def project_id(self) -> Optional[str]:
         return self._project_id
 
     @project_id.setter
-    @property_not_nullable
-    def project_id(self, value: str):
+    def project_id(self, value: Optional[str]):
         self._project_id = value
 
     @property
@@ -306,50 +305,16 @@ class DatasourceItem(object):
         all_datasource_xml = parsed_response.findall(".//t:datasource", namespaces=ns)
 
         for datasource_xml in all_datasource_xml:
-            (
-                ask_data_enablement,
-                certified,
-                certification_note,
-                content_url,
-                created_at,
-                datasource_type,
-                description,
-                encrypt_extracts,
-                has_extracts,
-                id_,
-                name,
-                owner_id,
-                project_id,
-                project_name,
-                tags,
-                updated_at,
-                use_remote_query_agent,
-                webpage_url,
-            ) = cls._parse_element(datasource_xml, ns)
-            datasource_item = cls(project_id)
-            datasource_item._set_values(
-                ask_data_enablement,
-                certified,
-                certification_note,
-                content_url,
-                created_at,
-                datasource_type,
-                description,
-                encrypt_extracts,
-                has_extracts,
-                id_,
-                name,
-                owner_id,
-                None,
-                project_name,
-                tags,
-                updated_at,
-                use_remote_query_agent,
-                webpage_url,
-            )
+            datasource_item = cls.from_xml(datasource_xml, ns)
             all_datasource_items.append(datasource_item)
         return all_datasource_items
 
+    @classmethod
+    def from_xml(cls, datasource_xml, ns):
+        datasource_item = cls()
+        datasource_item._set_values(*cls._parse_element(datasource_xml, ns))
+        return datasource_item
+
     @staticmethod
     def _parse_element(datasource_xml: ET.Element, ns: Dict) -> Tuple:
         id_ = datasource_xml.get("id", None)
@@ -361,17 +326,8 @@ class DatasourceItem(object):
         updated_at = parse_datetime(datasource_xml.get("updatedAt", None))
         certification_note = datasource_xml.get("certificationNote", None)
         certified = str(datasource_xml.get("isCertified", None)).lower() == "true"
-        certification_note = datasource_xml.get("certificationNote", None)
-        certified = str(datasource_xml.get("isCertified", None)).lower() == "true"
-        content_url = datasource_xml.get("contentUrl", None)
-        created_at = parse_datetime(datasource_xml.get("createdAt", None))
-        datasource_type = datasource_xml.get("type", None)
-        description = datasource_xml.get("description", None)
         encrypt_extracts = datasource_xml.get("encryptExtracts", None)
         has_extracts = datasource_xml.get("hasExtracts", None)
-        id_ = datasource_xml.get("id", None)
-        name = datasource_xml.get("name", None)
-        updated_at = parse_datetime(datasource_xml.get("updatedAt", None))
         use_remote_query_agent = datasource_xml.get("useRemoteQueryAgent", None)
         webpage_url = datasource_xml.get("webpageUrl", None)
 

tableauserverclient/models/favorites_item.py

@@ -1,74 +1,90 @@
 import logging
 
 from defusedxml.ElementTree import fromstring
+from .tableau_types import TableauItem
 
 from .datasource_item import DatasourceItem
 from .flow_item import FlowItem
 from .project_item import ProjectItem
+from .metric_item import MetricItem
 from .view_item import ViewItem
 from .workbook_item import WorkbookItem
+from typing import Dict, List
 
-logger = logging.getLogger("tableau.models.favorites_item")
-
+from tableauserverclient.helpers.logging import logger
 from typing import Dict, List, Union
 
 FavoriteType = Dict[
     str,
-    List[
-        Union[
-            DatasourceItem,
-            ProjectItem,
-            FlowItem,
-            ViewItem,
-            WorkbookItem,
-        ]
-    ],
+    List[TableauItem],
 ]
 
 
 class FavoriteItem:
-    class Type:
-        Workbook: str = "workbook"
-        Datasource: str = "datasource"
-        View: str = "view"
-        Project: str = "project"
-        Flow: str = "flow"
-
     @classmethod
     def from_response(cls, xml: str, namespace: Dict) -> FavoriteType:
         favorites: FavoriteType = {
             "datasources": [],
             "flows": [],
             "projects": [],
+            "metrics": [],
             "views": [],
             "workbooks": [],
         }
-
         parsed_response = fromstring(xml)
-        for workbook in parsed_response.findall(".//t:favorite/t:workbook", namespace):
-            fav_workbook = WorkbookItem("")
-            fav_workbook._set_values(*fav_workbook._parse_element(workbook, namespace))
-            if fav_workbook:
-                favorites["workbooks"].append(fav_workbook)
-        for view in parsed_response.findall(".//t:favorite[t:view]", namespace):
-            fav_views = ViewItem.from_xml_element(view, namespace)
-            if fav_views:
-                for fav_view in fav_views:
-                    favorites["views"].append(fav_view)
-        for datasource in parsed_response.findall(".//t:favorite/t:datasource", namespace):
-            fav_datasource = DatasourceItem("")
-            fav_datasource._set_values(*fav_datasource._parse_element(datasource, namespace))
+
+        datasources_xml = parsed_response.findall(".//t:favorite/t:datasource", namespace)
+        flows_xml = parsed_response.findall(".//t:favorite/t:flow", namespace)
+        metrics_xml = parsed_response.findall(".//t:favorite/t:metric", namespace)
+        projects_xml = parsed_response.findall(".//t:favorite/t:project", namespace)
+        views_xml = parsed_response.findall(".//t:favorite/t:view", namespace)
+        workbooks_xml = parsed_response.findall(".//t:favorite/t:workbook", namespace)
+
+        logger.debug(
+            "ds: {}, flows: {}, metrics: {}, projects: {}, views: {}, wbs: {}".format(
+                len(datasources_xml),
+                len(flows_xml),
+                len(metrics_xml),
+                len(projects_xml),
+                len(views_xml),
+                len(workbooks_xml),
+            )
+        )
+        for datasource in datasources_xml:
+            fav_datasource = DatasourceItem.from_xml(datasource, namespace)
             if fav_datasource:
+                logger.debug(fav_datasource)
                 favorites["datasources"].append(fav_datasource)
-        for project in parsed_response.findall(".//t:favorite/t:project", namespace):
-            fav_project = ProjectItem("p")
-            fav_project._set_values(*fav_project._parse_element(project))
-            if fav_project:
-                favorites["projects"].append(fav_project)
-        for flow in parsed_response.findall(".//t:favorite/t:flow", namespace):
-            fav_flow = FlowItem("flows")
-            fav_flow._set_values(*fav_flow._parse_element(flow, namespace))
+
+        for flow in flows_xml:
+            fav_flow = FlowItem.from_xml(flow, namespace)
             if fav_flow:
+                logger.debug(fav_flow)
                 favorites["flows"].append(fav_flow)
 
+        for metric in metrics_xml:
+            fav_metric = MetricItem.from_xml(metric, namespace)
+            if fav_metric:
+                logger.debug(fav_metric)
+                favorites["metrics"].append(fav_metric)
+
+        for project in projects_xml:
+            fav_project = ProjectItem.from_xml(project, namespace)
+            if fav_project:
+                logger.debug(fav_project)
+                favorites["projects"].append(fav_project)
+
+        for view in views_xml:
+            fav_view = ViewItem.from_xml(view, namespace)
+            if fav_view:
+                logger.debug(fav_view)
+                favorites["views"].append(fav_view)
+
+        for workbook in workbooks_xml:
+            fav_workbook = WorkbookItem.from_xml(workbook, namespace)
+            if fav_workbook:
+                logger.debug(fav_workbook)
+                favorites["workbooks"].append(fav_workbook)
+
+        logger.debug(favorites)
         return favorites

tableauserverclient/models/fileupload_item.py

@@ -11,8 +11,8 @@ class FileuploadItem(object):
         return self._upload_session_id
 
     @property
-    def file_size(self):
-        return self._file_size
+    def file_size(self) -> int:
+        return int(self._file_size)
 
     @classmethod
     def from_response(cls, resp, ns):

tableauserverclient/models/flow_item.py

@@ -176,34 +176,39 @@ class FlowItem(object):
         all_flow_xml = parsed_response.findall(".//t:flow", namespaces=ns)
 
         for flow_xml in all_flow_xml:
-            (
-                id_,
-                name,
-                description,
-                webpage_url,
-                created_at,
-                updated_at,
-                tags,
-                project_id,
-                project_name,
-                owner_id,
-            ) = cls._parse_element(flow_xml, ns)
-            flow_item = cls(project_id)
-            flow_item._set_values(
-                id_,
-                name,
-                description,
-                webpage_url,
-                created_at,
-                updated_at,
-                tags,
-                None,
-                project_name,
-                owner_id,
-            )
+            flow_item = cls.from_xml(flow_xml, ns)
             all_flow_items.append(flow_item)
         return all_flow_items
 
+    @classmethod
+    def from_xml(cls, flow_xml, ns) -> "FlowItem":
+        (
+            id_,
+            name,
+            description,
+            webpage_url,
+            created_at,
+            updated_at,
+            tags,
+            project_id,
+            project_name,
+            owner_id,
+        ) = cls._parse_element(flow_xml, ns)
+        flow_item = cls(project_id)
+        flow_item._set_values(
+            id_,
+            name,
+            description,
+            webpage_url,
+            created_at,
+            updated_at,
+            tags,
+            None,
+            project_name,
+            owner_id,
+        )
+        return flow_item
+
     @staticmethod
     def _parse_element(flow_xml, ns):
         id_ = flow_xml.get("id", None)

tableauserverclient/models/group_item.py

@@ -26,11 +26,9 @@ class GroupItem(object):
         self.name: Optional[str] = name
         self.domain_name: Optional[str] = domain_name
 
-    def __str__(self):
+    def __repr__(self):
         return "{}({!r})".format(self.__class__.__name__, self.__dict__)
 
-    __repr__ = __str__
-
     @property
     def domain_name(self) -> Optional[str]:
         return self._domain_name
@@ -48,7 +46,6 @@ class GroupItem(object):
         return self._name
 
     @name.setter
-    @property_not_empty
     def name(self, value: str) -> None:
         self._name = value
 

tableauserverclient/models/interval_item.py

@@ -31,6 +31,9 @@ class HourlyInterval(object):
         self.end_time = end_time
         self.interval = interval_value
 
+    def __repr__(self):
+        return f"<{self.__class__.__name__} start={self.start_time} end={self.end_time} interval={self.interval}>"
+
     @property
     def _frequency(self):
         return IntervalItem.Frequency.Hourly
@@ -86,6 +89,9 @@ class DailyInterval(object):
         self.start_time = start_time
         self.interval = interval_values
 
+    def __repr__(self):
+        return f"<{self.__class__.__name__} start={self.start_time} interval={self.interval}>"
+
     @property
     def _frequency(self):
         return IntervalItem.Frequency.Daily
@@ -114,6 +120,9 @@ class WeeklyInterval(object):
         self.start_time = start_time
         self.interval = interval_values
 
+    def __repr__(self):
+        return f"<{self.__class__.__name__} start={self.start_time} interval={self.interval}>"
+
     @property
     def _frequency(self):
         return IntervalItem.Frequency.Weekly
@@ -148,6 +157,9 @@ class MonthlyInterval(object):
         self.start_time = start_time
         self.interval = str(interval_value)
 
+    def __repr__(self):
+        return f"<{self.__class__.__name__} start={self.start_time} interval={self.interval}>"
+
     @property
     def _frequency(self):
         return IntervalItem.Frequency.Monthly

tableauserverclient/models/job_item.py

@@ -117,12 +117,15 @@ class JobItem(object):
     def updated_at(self) -> Optional[datetime.datetime]:
         return self._updated_at
 
-    def __repr__(self):
+    def __str__(self):
         return (
             "<Job#{_id} {_type} created_at({_created_at}) started_at({_started_at}) updated_at({_updated_at}) completed_at({_completed_at})"
             " progress ({_progress}) finish_code({_finish_code})>".format(**self.__dict__)
         )
 
+    def __repr__(self):
+        return self.__str__() + "  { " + ", ".join(" % s: % s" % item for item in vars(self).items()) + "}"
+
     @classmethod
     def from_response(cls, xml, ns) -> List["JobItem"]:
         parsed_response = fromstring(xml)
@@ -202,6 +205,12 @@ class BackgroundJobItem(object):
         self._title = title
         self._subtitle = subtitle
 
+    def __str__(self):
+        return f"<{self.__class__.name} {self._id} {self._type}>"
+
+    def __repr__(self):
+        return self.__str__() + "  { " + ", ".join(" % s: % s" % item for item in vars(self).items()) + "}"
+
     @property
     def id(self) -> str:
         return self._id