tableauserverclient 0.28__tar.gz → 0.30__tar.gz

{tableauserverclient-0.28 → tableauserverclient-0.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tableauserverclient
-Version: 0.28
+Version: 0.30
 Summary: A Python module for working with the Tableau Server REST API.
 Author-email: Tableau <github@tableau.com>
 License: The MIT License (MIT)
@@ -40,7 +40,7 @@ License-File: LICENSE.versioneer
 Requires-Dist: defusedxml>=0.7.1
 Requires-Dist: packaging>=23.1
 Requires-Dist: requests>=2.31
-Requires-Dist: urllib3==2.0.6
+Requires-Dist: urllib3==2.0.7
 Provides-Extra: test
 Requires-Dist: argparse; extra == "test"
 Requires-Dist: black==23.7; extra == "test"

{tableauserverclient-0.28 → tableauserverclient-0.30}/contributing.md

@@ -10,8 +10,7 @@ Contribution can include, but are not limited to, any of the following:
 * Fix an Issue/Bug
 * Add/Fix documentation
 
-Contributions must follow the guidelines outlined on the [Tableau Organization](http://tableau.github.io/) page, though filing an issue or requesting
-a feature do not require the CLA.
+Contributions must follow the guidelines outlined on the [Tableau Organization](http://tableau.github.io/) page, though filing an issue or requesting a feature do not require the CLA.
 
 ## Issues and Feature Requests
 

{tableauserverclient-0.28 → tableauserverclient-0.30}/pyproject.toml

@@ -15,7 +15,7 @@ dependencies = [
     'defusedxml>=0.7.1',  # latest as at 7/31/23
     'packaging>=23.1',   # latest as at 7/31/23
     'requests>=2.31',  # latest as at 7/31/23
-    'urllib3==2.0.6',  # latest as at 7/31/23
+    'urllib3==2.0.7',  # latest as at 7/31/23
 ]
 requires-python = ">=3.7"
 classifiers = [

{tableauserverclient-0.28 → tableauserverclient-0.30}/samples/getting_started/3_hello_universe.py

@@ -62,11 +62,6 @@ def main():
             print("{} jobs".format(pagination.total_available))
             print(jobs[0])
 
-        metrics, pagination = server.metrics.get()
-        if metrics:
-            print("{} metrics".format(pagination.total_available))
-            print(metrics[0])
-
         schedules, pagination = server.schedules.get()
         if schedules:
             print("{} schedules".format(pagination.total_available))
@@ -82,7 +77,7 @@ def main():
             print("{} webhooks".format(pagination.total_available))
             print(webhooks[0])
 
-        users, pagination = server.metrics.get()
+        users, pagination = server.users.get()
         if users:
             print("{} users".format(pagination.total_available))
             print(users[0])
@@ -92,5 +87,6 @@ def main():
             print("{} groups".format(pagination.total_available))
             print(groups[0])
 
-    if __name__ == "__main__":
-        main()
+
+if __name__ == "__main__":
+    main()

{tableauserverclient-0.28 → tableauserverclient-0.30}/tableauserverclient/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2023-10-04T00:33:03-0700",
+ "date": "2024-01-19T11:30:24-0800",
  "dirty": false,
  "error": null,
- "full-revisionid": "72eb3c8500193e4f20defa20c8a6f8bbf34b2f43",
- "version": "0.28"
+ "full-revisionid": "f84d7d5302344f0a4ac369c501b122931ae7e79e",
+ "version": "0.30"
 }
 '''  # END VERSION_JSON
 

{tableauserverclient-0.28 → tableauserverclient-0.30}/tableauserverclient/config.py

@@ -7,7 +7,7 @@ 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
+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

tableauserverclient-0.30/tableauserverclient/helpers/headers.py

@@ -0,0 +1,17 @@
+from copy import deepcopy
+from urllib.parse import unquote_plus
+
+
+def fix_filename(params):
+    if "filename*" not in params:
+        return params
+
+    params = deepcopy(params)
+    filename = params["filename*"]
+    prefix = "UTF-8''"
+    if filename.startswith(prefix):
+        filename = filename[len(prefix) :]
+
+    params["filename"] = unquote_plus(filename)
+    del params["filename*"]
+    return params

{tableauserverclient-0.28 → tableauserverclient-0.30}/tableauserverclient/helpers/strings.py

@@ -9,8 +9,6 @@ from typing import TypeVar
 T = TypeVar("T", str, bytes)
 
 
-# usage: _redact_any_type("<xml workbook password= cooliothesecond>")
-# -> b"<xml workbook password =***************">
 def _redact_any_type(xml: T, sensitive_word: T, replacement: T, encoding=None) -> T:
     try:
         root = fromstring(xml)

tableauserverclient-0.30/tableauserverclient/models/interval_item.py

@@ -0,0 +1,268 @@
+from .property_decorators import property_is_valid_time, property_not_nullable
+
+
+class IntervalItem(object):
+    class Frequency:
+        Hourly = "Hourly"
+        Daily = "Daily"
+        Weekly = "Weekly"
+        Monthly = "Monthly"
+
+    class Occurrence:
+        Minutes = "minutes"
+        Hours = "hours"
+        WeekDay = "weekDay"
+        MonthDay = "monthDay"
+
+    class Day:
+        Sunday = "Sunday"
+        Monday = "Monday"
+        Tuesday = "Tuesday"
+        Wednesday = "Wednesday"
+        Thursday = "Thursday"
+        Friday = "Friday"
+        Saturday = "Saturday"
+        LastDay = "LastDay"
+
+
+class HourlyInterval(object):
+    def __init__(self, start_time, end_time, interval_value):
+        self.start_time = start_time
+        self.end_time = end_time
+
+        # interval should be a tuple, if it is not, assign as a tuple with single value
+        if isinstance(interval_value, tuple):
+            self.interval = interval_value
+        else:
+            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
+
+    @property
+    def start_time(self):
+        return self._start_time
+
+    @start_time.setter
+    @property_is_valid_time
+    @property_not_nullable
+    def start_time(self, value):
+        self._start_time = value
+
+    @property
+    def end_time(self):
+        return self._end_time
+
+    @end_time.setter
+    @property_is_valid_time
+    @property_not_nullable
+    def end_time(self, value):
+        self._end_time = value
+
+    @property
+    def interval(self):
+        return self._interval
+
+    @interval.setter
+    def interval(self, intervals):
+        VALID_INTERVALS = {0.25, 0.5, 1, 2, 4, 6, 8, 12, 24}
+        for interval in intervals:
+            # if an hourly interval is a string, then it is a weekDay interval
+            if isinstance(interval, str) and not interval.isnumeric() and not hasattr(IntervalItem.Day, interval):
+                error = "Invalid weekDay interval {}".format(interval)
+                raise ValueError(error)
+
+            # if an hourly interval is a number, it is an hours or minutes interval
+            if isinstance(interval, (int, float)) and float(interval) not in VALID_INTERVALS:
+                error = "Invalid interval {} not in {}".format(interval, str(VALID_INTERVALS))
+                raise ValueError(error)
+
+        self._interval = intervals
+
+    def _interval_type_pairs(self):
+        interval_type_pairs = []
+        for interval in self.interval:
+            # We use fractional hours for the two minute-based intervals.
+            # Need to convert to minutes from hours here
+            if interval in {0.25, 0.5}:
+                calculated_interval = int(interval * 60)
+                interval_type = IntervalItem.Occurrence.Minutes
+
+                interval_type_pairs.append((interval_type, str(calculated_interval)))
+            else:
+                # if the interval is a non-numeric string, it will always be a weekDay
+                if isinstance(interval, str) and not interval.isnumeric():
+                    interval_type = IntervalItem.Occurrence.WeekDay
+
+                    interval_type_pairs.append((interval_type, str(interval)))
+                # otherwise the interval is hours
+                else:
+                    interval_type = IntervalItem.Occurrence.Hours
+
+                    interval_type_pairs.append((interval_type, str(interval)))
+
+        return interval_type_pairs
+
+
+class DailyInterval(object):
+    def __init__(self, start_time, *interval_values):
+        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
+
+    @property
+    def start_time(self):
+        return self._start_time
+
+    @start_time.setter
+    @property_is_valid_time
+    @property_not_nullable
+    def start_time(self, value):
+        self._start_time = value
+
+    @property
+    def interval(self):
+        return self._interval
+
+    @interval.setter
+    def interval(self, intervals):
+        VALID_INTERVALS = {0.25, 0.5, 1, 2, 4, 6, 8, 12}
+
+        for interval in intervals:
+            # if an hourly interval is a string, then it is a weekDay interval
+            if isinstance(interval, str) and not interval.isnumeric() and not hasattr(IntervalItem.Day, interval):
+                error = "Invalid weekDay interval {}".format(interval)
+                raise ValueError(error)
+
+            # if an hourly interval is a number, it is an hours or minutes interval
+            if isinstance(interval, (int, float)) and float(interval) not in VALID_INTERVALS:
+                error = "Invalid interval {} not in {}".format(interval, str(VALID_INTERVALS))
+                raise ValueError(error)
+
+        self._interval = intervals
+
+    def _interval_type_pairs(self):
+        interval_type_pairs = []
+        for interval in self.interval:
+            # We use fractional hours for the two minute-based intervals.
+            # Need to convert to minutes from hours here
+            if interval in {0.25, 0.5}:
+                calculated_interval = int(interval * 60)
+                interval_type = IntervalItem.Occurrence.Minutes
+
+                interval_type_pairs.append((interval_type, str(calculated_interval)))
+            else:
+                # if the interval is a non-numeric string, it will always be a weekDay
+                if isinstance(interval, str) and not interval.isnumeric():
+                    interval_type = IntervalItem.Occurrence.WeekDay
+
+                    interval_type_pairs.append((interval_type, str(interval)))
+                # otherwise the interval is hours
+                else:
+                    interval_type = IntervalItem.Occurrence.Hours
+
+                    interval_type_pairs.append((interval_type, str(interval)))
+
+        return interval_type_pairs
+
+
+class WeeklyInterval(object):
+    def __init__(self, start_time, *interval_values):
+        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
+
+    @property
+    def start_time(self):
+        return self._start_time
+
+    @start_time.setter
+    @property_is_valid_time
+    @property_not_nullable
+    def start_time(self, value):
+        self._start_time = value
+
+    @property
+    def interval(self):
+        return self._interval
+
+    @interval.setter
+    def interval(self, interval_values):
+        if not all(hasattr(IntervalItem.Day, day) for day in interval_values):
+            raise ValueError("Invalid week day defined " + str(interval_values))
+
+        self._interval = interval_values
+
+    def _interval_type_pairs(self):
+        return [(IntervalItem.Occurrence.WeekDay, day) for day in self.interval]
+
+
+class MonthlyInterval(object):
+    def __init__(self, start_time, interval_value):
+        self.start_time = start_time
+
+        # interval should be a tuple, if it is not, assign as a tuple with single value
+        if isinstance(interval_value, tuple):
+            self.interval = interval_value
+        else:
+            self.interval = (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
+
+    @property
+    def start_time(self):
+        return self._start_time
+
+    @start_time.setter
+    @property_is_valid_time
+    @property_not_nullable
+    def start_time(self, value):
+        self._start_time = value
+
+    @property
+    def interval(self):
+        return self._interval
+
+    @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
+        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)
+
+        self._interval = interval_values
+
+    def _interval_type_pairs(self):
+        return [(IntervalItem.Occurrence.MonthDay, self.interval)]

{tableauserverclient-0.28 → tableauserverclient-0.30}/tableauserverclient/models/project_item.py

@@ -163,9 +163,6 @@ class ProjectItem(object):
             attr,
             permissions,
         )
-        fetch_call = getattr(self, attr)
-        logging.getLogger().info({"type": attr, "value": fetch_call()})
-        return fetch_call()
 
     @classmethod
     def from_response(cls, resp, ns) -> List["ProjectItem"]:

{tableauserverclient-0.28 → tableauserverclient-0.30}/tableauserverclient/models/schedule_item.py

@@ -254,25 +254,43 @@ class ScheduleItem(object):
             interval.extend(interval_elem.attrib.items())
 
         if frequency == IntervalItem.Frequency.Daily:
-            return DailyInterval(start_time)
+            converted_intervals = []
+
+            for i in interval:
+                # We use fractional hours for the two minute-based intervals.
+                # Need to convert to hours from minutes here
+                if i[0] == IntervalItem.Occurrence.Minutes:
+                    converted_intervals.append(float(i[1]) / 60)
+                elif i[0] == IntervalItem.Occurrence.Hours:
+                    converted_intervals.append(float(i[1]))
+                else:
+                    converted_intervals.append(i[1])
+
+            return DailyInterval(start_time, *converted_intervals)
 
         if frequency == IntervalItem.Frequency.Hourly:
-            interval_occurrence, interval_value = interval.pop()
+            converted_intervals = []
 
-            # We use fractional hours for the two minute-based intervals.
-            # Need to convert to hours from minutes here
-            if interval_occurrence == IntervalItem.Occurrence.Minutes:
-                interval_value = float(interval_value) / 60
+            for i in interval:
+                # We use fractional hours for the two minute-based intervals.
+                # Need to convert to hours from minutes here
+                if i[0] == IntervalItem.Occurrence.Minutes:
+                    converted_intervals.append(float(i[1]) / 60)
+                elif i[0] == IntervalItem.Occurrence.Hours:
+                    converted_intervals.append(i[1])
+                else:
+                    converted_intervals.append(i[1])
 
-            return HourlyInterval(start_time, end_time, interval_value)
+            return HourlyInterval(start_time, end_time, tuple(converted_intervals))
 
         if frequency == IntervalItem.Frequency.Weekly:
             interval_values = [i[1] for i in interval]
             return WeeklyInterval(start_time, *interval_values)
 
         if frequency == IntervalItem.Frequency.Monthly:
-            interval_occurrence, interval_value = interval.pop()
-            return MonthlyInterval(start_time, interval_value)
+            interval_values = [i[1] for i in interval]
+
+            return MonthlyInterval(start_time, tuple(interval_values))
 
     @staticmethod
     def _parse_element(schedule_xml, ns):

{tableauserverclient-0.28 → tableauserverclient-0.30}/tableauserverclient/models/task_item.py

@@ -1,8 +1,11 @@
+from datetime import datetime
+from typing import List, Optional
+
 from defusedxml.ElementTree import fromstring
 
 from tableauserverclient.datetime_helpers import parse_datetime
-from .schedule_item import ScheduleItem
-from .target import Target
+from tableauserverclient.models.schedule_item import ScheduleItem
+from tableauserverclient.models.target import Target
 
 
 class TaskItem(object):
@@ -19,14 +22,14 @@ class TaskItem(object):
 
     def __init__(
         self,
-        id_,
-        task_type,
-        priority,
-        consecutive_failed_count=0,
-        schedule_id=None,
-        schedule_item=None,
-        last_run_at=None,
-        target=None,
+        id_: str,
+        task_type: str,
+        priority: int,
+        consecutive_failed_count: int = 0,
+        schedule_id: Optional[str] = None,
+        schedule_item: Optional[ScheduleItem] = None,
+        last_run_at: Optional[datetime] = None,
+        target: Optional[Target] = None,
     ):
         self.id = id_
         self.task_type = task_type
@@ -37,14 +40,14 @@ class TaskItem(object):
         self.last_run_at = last_run_at
         self.target = target
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return (
             "<Task#{id} {task_type} pri({priority}) failed({consecutive_failed_count}) schedule_id({"
             "schedule_id}) target({target})>".format(**self.__dict__)
         )
 
     @classmethod
-    def from_response(cls, xml, ns, task_type=Type.ExtractRefresh):
+    def from_response(cls, xml, ns, task_type=Type.ExtractRefresh) -> List["TaskItem"]:
         parsed_response = fromstring(xml)
         all_tasks_xml = parsed_response.findall(".//t:task/t:{}".format(task_type), namespaces=ns)
 
@@ -62,8 +65,7 @@ class TaskItem(object):
         last_run_at_element = element.find(".//t:lastRunAt", namespaces=ns)
 
         schedule_item_list = ScheduleItem.from_element(element, ns)
-        if len(schedule_item_list) >= 1:
-            schedule_item = schedule_item_list[0]
+        schedule_item = next(iter(schedule_item_list), None)
 
         # according to the Tableau Server REST API documentation,
         # there should be only one of workbook or datasource
@@ -87,14 +89,14 @@ class TaskItem(object):
             task_type,
             priority,
             consecutive_failed_count,
-            schedule_item.id,
+            schedule_item.id if schedule_item is not None else None,
             schedule_item,
             last_run_at,
             target,
         )
 
     @staticmethod
-    def _translate_task_type(task_type):
+    def _translate_task_type(task_type: str) -> str:
         if task_type in TaskItem._TASK_TYPE_MAPPING:
             return TaskItem._TASK_TYPE_MAPPING[task_type]
         else:

{tableauserverclient-0.28 → tableauserverclient-0.30}/tableauserverclient/server/endpoint/datasources_endpoint.py

@@ -8,6 +8,8 @@ from contextlib import closing
 from pathlib import Path
 from typing import List, Mapping, Optional, Sequence, Tuple, TYPE_CHECKING, Union
 
+from tableauserverclient.helpers.headers import fix_filename
+
 if TYPE_CHECKING:
     from tableauserverclient.server import Server
     from tableauserverclient.models import PermissionsRule
@@ -441,6 +443,7 @@ class Datasources(QuerysetEndpoint):
                     filepath.write(chunk)
                 return_path = filepath
             else:
+                params = fix_filename(params)
                 filename = to_filename(os.path.basename(params["filename"]))
                 download_path = make_download_path(filepath, filename)
                 with open(download_path, "wb") as f:

{tableauserverclient-0.28 → tableauserverclient-0.30}/tableauserverclient/server/endpoint/endpoint.py

@@ -1,8 +1,5 @@
-from threading import Thread
-from time import sleep
 from tableauserverclient import datetime_helpers as datetime
 
-import requests
 from packaging.version import Version
 from functools import wraps
 from xml.etree.ElementTree import ParseError
@@ -76,58 +73,21 @@ class Endpoint(object):
         # return explicitly for testing only
         return parameters
 
-    def _blocking_request(self, method, url, parameters={}) -> Optional["Response"]:
-        self.async_response = None
+    def _blocking_request(self, method, url, parameters={}) -> Optional[Union["Response", Exception]]:
         response = None
         logger.debug("[{}] Begin blocking request to {}".format(datetime.timestamp(), url))
         try:
             response = method(url, **parameters)
-            self.async_response = response
             logger.debug("[{}] Call finished".format(datetime.timestamp()))
         except Exception as e:
             logger.debug("Error making request to server: {}".format(e))
-            self.async_response = e
-        finally:
-            if response and not self.async_response:
-                logger.debug("Request response not saved")
-                return None
-        logger.debug("[{}] Request complete".format(datetime.timestamp()))
-        return self.async_response
+            raise e
+        return response
 
     def send_request_while_show_progress_threaded(
-        self, method, url, parameters={}, request_timeout=0
-    ) -> Optional["Response"]:
-        try:
-            request_thread = Thread(target=self._blocking_request, args=(method, url, parameters))
-            request_thread.async_response = -1  # type:ignore # this is an invented attribute for thread comms
-            request_thread.start()
-        except Exception as e:
-            logger.debug("Error starting server request on separate thread: {}".format(e))
-            return None
-        seconds = 0
-        minutes = 0
-        sleep(1)
-        if self.async_response != -1:
-            # a quick return for any immediate responses
-            return self.async_response
-        while self.async_response == -1 and (request_timeout == 0 or seconds < request_timeout):
-            self.log_wait_time_then_sleep(minutes, seconds, url)
-            seconds = seconds + DELAY_SLEEP_SECONDS
-            if seconds >= 60:
-                seconds = 0
-                minutes = minutes + 1
-        return self.async_response
-
-    def log_wait_time_then_sleep(self, minutes, seconds, url):
-        logger.debug("{} Waiting....".format(datetime.timestamp()))
-        if seconds >= 60:  # detailed log message ~every minute
-            if minutes % 5 == 0:
-                logger.info(
-                    "[{}] Waiting ({} minutes so far) for request to {}".format(datetime.timestamp(), minutes, url)
-                )
-            else:
-                logger.debug("[{}] Waiting for request to {}".format(datetime.timestamp(), url))
-        sleep(DELAY_SLEEP_SECONDS)
+        self, method, url, parameters={}, request_timeout=None
+    ) -> Optional[Union["Response", Exception]]:
+        return self._blocking_request(method, url, parameters)
 
     def _make_request(
         self,
@@ -151,7 +111,7 @@ class Endpoint(object):
         # a request can, for stuff like publishing, spin for ages waiting for a response.
         # we need some user-facing activity so they know it's not dead.
         request_timeout = self.parent_srv.http_options.get("timeout") or 0
-        server_response: Optional["Response"] = self.send_request_while_show_progress_threaded(
+        server_response: Optional[Union["Response", Exception]] = self.send_request_while_show_progress_threaded(
             method, url, parameters, request_timeout
         )
         logger.debug("[{}] Async request returned: received {}".format(datetime.timestamp(), server_response))
@@ -163,6 +123,8 @@ class Endpoint(object):
         if server_response is None:
             logger.debug("[{}] Request failed".format(datetime.timestamp()))
             raise RuntimeError
+        if isinstance(server_response, Exception):
+            raise server_response
         self._check_status(server_response, url)
 
         loggable_response = self.log_response_safely(server_response)

{tableauserverclient-0.28 → tableauserverclient-0.30}/tableauserverclient/server/endpoint/flows_endpoint.py

@@ -7,6 +7,8 @@ from contextlib import closing
 from pathlib import Path
 from typing import Iterable, List, Optional, TYPE_CHECKING, Tuple, Union
 
+from tableauserverclient.helpers.headers import fix_filename
+
 from .dqw_endpoint import _DataQualityWarningEndpoint
 from .endpoint import QuerysetEndpoint, api
 from .exceptions import InternalServerError, MissingRequiredFieldError
@@ -124,6 +126,7 @@ class Flows(QuerysetEndpoint):
                     filepath.write(chunk)
                 return_path = filepath
             else:
+                params = fix_filename(params)
                 filename = to_filename(os.path.basename(params["filename"]))
                 download_path = make_download_path(filepath, filename)
                 with open(download_path, "wb") as f: