tableauserverclient 0.28__py3-none-any.whl → 0.30__py3-none-any.whl

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/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/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/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/models/interval_item.py

@@ -29,7 +29,12 @@ class HourlyInterval(object):
     def __init__(self, start_time, end_time, interval_value):
         self.start_time = start_time
         self.end_time = end_time
-        self.interval = interval_value
+
+        # 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}>"
@@ -63,25 +68,44 @@ class HourlyInterval(object):
         return self._interval
 
     @interval.setter
-    def interval(self, interval):
-        VALID_INTERVALS = {0.25, 0.5, 1, 2, 4, 6, 8, 12}
-        if float(interval) not in VALID_INTERVALS:
-            error = "Invalid interval {} not in {}".format(interval, str(VALID_INTERVALS))
-            raise ValueError(error)
+    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)
 
-        self._interval = interval
+            # 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):
-        # We use fractional hours for the two minute-based intervals.
-        # Need to convert to minutes from hours here
-        if self.interval in {0.25, 0.5}:
-            calculated_interval = int(self.interval * 60)
-            interval_type = IntervalItem.Occurrence.Minutes
-        else:
-            calculated_interval = self.interval
-            interval_type = IntervalItem.Occurrence.Hours
+        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
 
-        return [(interval_type, str(calculated_interval))]
+                    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):
@@ -111,8 +135,45 @@ class DailyInterval(object):
         return self._interval
 
     @interval.setter
-    def interval(self, interval):
-        self._interval = interval
+    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):
@@ -155,7 +216,12 @@ class WeeklyInterval(object):
 class MonthlyInterval(object):
     def __init__(self, start_time, interval_value):
         self.start_time = start_time
-        self.interval = str(interval_value)
+
+        # 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}>"
@@ -179,24 +245,24 @@ class MonthlyInterval(object):
         return self._interval
 
     @interval.setter
-    def interval(self, interval_value):
-        error = "Invalid interval value for a monthly frequency: {}.".format(interval_value)
-
+    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)
+            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 = str(interval_value)
+        self._interval = interval_values
 
     def _interval_type_pairs(self):
         return [(IntervalItem.Occurrence.MonthDay, self.interval)]

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/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/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/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/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/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:

tableauserverclient/server/endpoint/tasks_endpoint.py

@@ -1,19 +1,23 @@
 import logging
+from typing import List, Optional, Tuple, TYPE_CHECKING
 
-from .endpoint import Endpoint, api
-from .exceptions import MissingRequiredFieldError
+from tableauserverclient.server.endpoint.endpoint import Endpoint, api
+from tableauserverclient.server.endpoint.exceptions import MissingRequiredFieldError
 from tableauserverclient.models import TaskItem, PaginationItem
 from tableauserverclient.server import RequestFactory
 
 from tableauserverclient.helpers.logging import logger
 
+if TYPE_CHECKING:
+    from tableauserverclient.server.request_options import RequestOptions
+
 
 class Tasks(Endpoint):
     @property
-    def baseurl(self):
+    def baseurl(self) -> str:
         return "{0}/sites/{1}/tasks".format(self.parent_srv.baseurl, self.parent_srv.site_id)
 
-    def __normalize_task_type(self, task_type):
+    def __normalize_task_type(self, task_type: str) -> str:
         """
         The word for extract refresh used in API URL is "extractRefreshes".
         It is different than the tag "extractRefresh" used in the request body.
@@ -24,11 +28,13 @@ class Tasks(Endpoint):
             return task_type
 
     @api(version="2.6")
-    def get(self, req_options=None, task_type=TaskItem.Type.ExtractRefresh):
+    def get(
+        self, req_options: Optional["RequestOptions"] = None, task_type: str = TaskItem.Type.ExtractRefresh
+    ) -> Tuple[List[TaskItem], PaginationItem]:
         if task_type == TaskItem.Type.DataAcceleration:
             self.parent_srv.assert_at_least_version("3.8", "Data Acceleration Tasks")
 
-        logger.info("Querying all {} tasks for the site".format(task_type))
+        logger.info("Querying all %s tasks for the site", task_type)
 
         url = "{0}/{1}".format(self.baseurl, self.__normalize_task_type(task_type))
         server_response = self.get_request(url, req_options)
@@ -38,11 +44,11 @@ class Tasks(Endpoint):
         return all_tasks, pagination_item
 
     @api(version="2.6")
-    def get_by_id(self, task_id):
+    def get_by_id(self, task_id: str) -> TaskItem:
         if not task_id:
             error = "No Task ID provided"
             raise ValueError(error)
-        logger.info("Querying a single task by id ({})".format(task_id))
+        logger.info("Querying a single task by id %s", task_id)
         url = "{}/{}/{}".format(
             self.baseurl,
             self.__normalize_task_type(TaskItem.Type.ExtractRefresh),
@@ -56,14 +62,14 @@ class Tasks(Endpoint):
         if not extract_item:
             error = "No extract refresh provided"
             raise ValueError(error)
-        logger.info("Creating an extract refresh ({})".format(extract_item))
+        logger.info("Creating an extract refresh %s", extract_item)
         url = "{0}/{1}".format(self.baseurl, self.__normalize_task_type(TaskItem.Type.ExtractRefresh))
         create_req = RequestFactory.Task.create_extract_req(extract_item)
         server_response = self.post_request(url, create_req)
         return server_response.content
 
     @api(version="2.6")
-    def run(self, task_item):
+    def run(self, task_item: TaskItem) -> bytes:
         if not task_item.id:
             error = "Task item missing ID."
             raise MissingRequiredFieldError(error)
@@ -79,7 +85,7 @@ class Tasks(Endpoint):
 
     # Delete 1 task by id
     @api(version="3.6")
-    def delete(self, task_id, task_type=TaskItem.Type.ExtractRefresh):
+    def delete(self, task_id: str, task_type: str = TaskItem.Type.ExtractRefresh) -> None:
         if task_type == TaskItem.Type.DataAcceleration:
             self.parent_srv.assert_at_least_version("3.8", "Data Acceleration Tasks")
 
@@ -88,4 +94,4 @@ class Tasks(Endpoint):
             raise ValueError(error)
         url = "{0}/{1}/{2}".format(self.baseurl, self.__normalize_task_type(task_type), task_id)
         self.delete_request(url)
-        logger.info("Deleted single task (ID: {0})".format(task_id))
+        logger.info("Deleted single task (ID: %s)", task_id)

tableauserverclient/server/endpoint/workbooks_endpoint.py

@@ -6,6 +6,8 @@ import os
 from contextlib import closing
 from pathlib import Path
 
+from tableauserverclient.helpers.headers import fix_filename
+
 from .endpoint import QuerysetEndpoint, api, parameter_added_in
 from .exceptions import InternalServerError, MissingRequiredFieldError
 from .permissions_endpoint import _PermissionsEndpoint
@@ -88,8 +90,8 @@ class Workbooks(QuerysetEndpoint):
         return WorkbookItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
     @api(version="2.8")
-    def refresh(self, workbook_id: str) -> JobItem:
-        id_ = getattr(workbook_id, "id", workbook_id)
+    def refresh(self, workbook_item: Union[WorkbookItem, str]) -> JobItem:
+        id_ = getattr(workbook_item, "id", workbook_item)
         url = "{0}/{1}/refresh".format(self.baseurl, id_)
         empty_req = RequestFactory.Empty.empty_req()
         server_response = self.post_request(url, empty_req)
@@ -455,7 +457,7 @@ class Workbooks(QuerysetEndpoint):
     def download_revision(
         self,
         workbook_id: str,
-        revision_number: str,
+        revision_number: Optional[str],
         filepath: Optional[PathOrFileW] = None,
         include_extract: bool = True,
         no_extract: Optional[bool] = None,
@@ -487,6 +489,7 @@ class Workbooks(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/server/request_factory.py

@@ -1032,6 +1032,16 @@ class TaskRequest(object):
     def create_extract_req(self, xml_request: ET.Element, extract_item: "TaskItem") -> bytes:
         extract_element = ET.SubElement(xml_request, "extractRefresh")
 
+        # Main attributes
+        extract_element.attrib["type"] = extract_item.task_type
+
+        if extract_item.target is not None:
+            target_element = ET.SubElement(extract_element, extract_item.target.type)
+            target_element.attrib["id"] = extract_item.target.id
+
+        if extract_item.schedule_item is None:
+            return ET.tostring(xml_request)
+
         # Schedule attributes
         schedule_element = ET.SubElement(xml_request, "schedule")
 
@@ -1043,17 +1053,11 @@ class TaskRequest(object):
             frequency_element.attrib["end"] = str(interval_item.end_time)
         if hasattr(interval_item, "interval") and interval_item.interval:
             intervals_element = ET.SubElement(frequency_element, "intervals")
-            for interval in interval_item._interval_type_pairs():
+            for interval in interval_item._interval_type_pairs():  # type: ignore
                 expression, value = interval
                 single_interval_element = ET.SubElement(intervals_element, "interval")
                 single_interval_element.attrib[expression] = value
 
-        # Main attributes
-        extract_element.attrib["type"] = extract_item.task_type
-
-        target_element = ET.SubElement(extract_element, extract_item.target.type)
-        target_element.attrib["id"] = extract_item.target.id
-
         return ET.tostring(xml_request)
 
 

tableauserverclient/server/request_options.py

@@ -37,35 +37,75 @@ class RequestOptions(RequestOptionsBase):
 
     class Field:
         Args = "args"
+        AuthenticationType = "authenticationType"
+        Caption = "caption"
+        Channel = "channel"
         CompletedAt = "completedAt"
+        ConnectedWorkbookType = "connectedWorkbookType"
+        ConnectionTo = "connectionTo"
+        ConnectionType = "connectionType"
         ContentUrl = "contentUrl"
         CreatedAt = "createdAt"
+        DatabaseName = "databaseName"
+        DatabaseUserName = "databaseUserName"
+        Description = "description"
+        DisplayTabs = "displayTabs"
         DomainName = "domainName"
         DomainNickname = "domainNickname"
+        FavoritesTotal = "favoritesTotal"
+        Fields = "fields"
+        FlowId = "flowId"
+        FriendlyName = "friendlyName"
+        HasAlert = "hasAlert"
+        HasAlerts = "hasAlerts"
+        HasEmbeddedPassword = "hasEmbeddedPassword"
+        HasExtracts = "hasExtracts"
         HitsTotal = "hitsTotal"
+        Id = "id"
+        IsCertified = "isCertified"
+        IsConnectable = "isConnectable"
+        IsDefaultPort = "isDefaultPort"
+        IsHierarchical = "isHierarchical"
         IsLocal = "isLocal"
+        IsPublished = "isPublished"
         JobType = "jobType"
         LastLogin = "lastLogin"
+        Luid = "luid"
         MinimumSiteRole = "minimumSiteRole"
         Name = "name"
         Notes = "notes"
+        NotificationType = "notificationType"
         OwnerDomain = "ownerDomain"
         OwnerEmail = "ownerEmail"
         OwnerName = "ownerName"
         ParentProjectId = "parentProjectId"
+        Priority = "priority"
         Progress = "progress"
+        ProjectId = "projectId"
         ProjectName = "projectName"
         PublishSamples = "publishSamples"
+        ServerName = "serverName"
+        ServerPort = "serverPort"
+        SheetCount = "sheetCount"
+        SheetNumber = "sheetNumber"
+        SheetType = "sheetType"
         SiteRole = "siteRole"
+        Size = "size"
         StartedAt = "startedAt"
         Status = "status"
+        SubscriptionsTotal = "subscriptionsTotal"
         Subtitle = "subtitle"
+        TableName = "tableName"
         Tags = "tags"
         Title = "title"
         TopLevelProject = "topLevelProject"
         Type = "type"
         UpdatedAt = "updatedAt"
         UserCount = "userCount"
+        UserId = "userId"
+        ViewUrlName = "viewUrlName"
+        WorkbookDescription = "workbookDescription"
+        WorkbookName = "workbookName"
 
     class Direction:
         Desc = "desc"

{tableauserverclient-0.28.dist-info → tableauserverclient-0.30.dist-info}/METADATA

@@ -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.dist-info → tableauserverclient-0.30.dist-info}/RECORD

@@ -1,14 +1,15 @@
 tableauserverclient/__init__.py,sha256=hDjLTdwXPmQj4BQBRdUcnP7XdhT7apJ_c7JAPyyYZ7Y,1096
-tableauserverclient/_version.py,sha256=77BR3Uhg7xOImjTULb4qcvv7VjeMtNO9xpnQ-eW_gLU,496
-tableauserverclient/config.py,sha256=u9YnTDv0XnFR0sUY6AdeSuP5Zi2WKmcgJGGdehuaoO0,429
+tableauserverclient/_version.py,sha256=1DZOBnxMpAUaNuob4jPBOvm74gFOHdcIzHXiKW4g43M,496
+tableauserverclient/config.py,sha256=frumJjDxOQug_R54kjrnHLyaIgg1bV7aUoNPHMJlBhc,430
 tableauserverclient/datetime_helpers.py,sha256=_-gWz5I2_KHT5AzW_boD8meH6loTTKdK-_62h1MA6ko,884
 tableauserverclient/exponential_backoff.py,sha256=HtAfbbVnYtiOe2_ZzKqZmsml40EDZBaC3bttif5qeG8,1474
 tableauserverclient/filesys_helpers.py,sha256=hosTm9fpc9B9_VCDcAuyHA0A-f-MWs9_2utyRweuZ5I,1667
 tableauserverclient/namespace.py,sha256=i0o0T0xO0vd1RX98o54xmIrqCkeVfhtQOGDMGRx_F_o,971
 tableauserverclient/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tableauserverclient/helpers/__init__.py,sha256=llpqF9zV5dsP5hQt8dyop33Op5OzGmxW0BZibaSlCcM,23
+tableauserverclient/helpers/headers.py,sha256=Pg-ZWSgV2Yp813BV1Tzo8F2Hn4P01zscla2RRM4yqNk,411
 tableauserverclient/helpers/logging.py,sha256=5q_oR3wERHVXFXY6XDnLYML5-HdAPJTmqhH9IZg4VfY,113
-tableauserverclient/helpers/strings.py,sha256=dnfm_2s75WvXnkcU8JFGRlLbSZdarRPyHpRYOi19APs,1682
+tableauserverclient/helpers/strings.py,sha256=HRTP31HIdD3gFxDDHuBsmOl_8cLdh8fa3xLALgYsUAQ,1563
 tableauserverclient/models/__init__.py,sha256=NfVfRDeU8b6zTQ7wzkorhvuGIPabym8lXvNiyEX_AVg,1620
 tableauserverclient/models/column_item.py,sha256=gV2r7xOVmcn9UnMXFOe9_ORZ85oha1KtIH-crKUhgN4,1972
 tableauserverclient/models/connection_credentials.py,sha256=8Wa8B_-cB3INFUup-Pyd5znsUD5opgYYH5TfipCzKTU,1559
@@ -25,16 +26,16 @@ tableauserverclient/models/fileupload_item.py,sha256=tx3LfgRxVqeHGpCN6kTDPkdBY5i
 tableauserverclient/models/flow_item.py,sha256=rPIVDe8_tHied8TDRiGpg2gyTyQWlNiGb3vGhqF9YJw,7320
 tableauserverclient/models/flow_run_item.py,sha256=pwJNz0m7l--Sb6z0o83ebWfAmTVFYSr-0apMxHWt0Vs,3139
 tableauserverclient/models/group_item.py,sha256=1KP_KmIG1veJJGyte82aFvMAiU_tvzYtaP2vLEReLoo,3621
-tableauserverclient/models/interval_item.py,sha256=h0mAFnR3rOj9nNOT237sPHQrdkN3NyonnGX10Chbx9k,5747
+tableauserverclient/models/interval_item.py,sha256=uSYQskXWlPFoQHC2wz58j6G93qhVKepMTYeWW9FbGaY,9053
 tableauserverclient/models/job_item.py,sha256=PMt7G2qu8WAxe-b3f_0BtQ9JcCSvk-g5L5EcOUpYFCY,8619
 tableauserverclient/models/metric_item.py,sha256=Zrzi_Un43p2jzE_4OhetxhjfeSUYzotMfm8Hjd5WOhI,5397
 tableauserverclient/models/pagination_item.py,sha256=Hdr2EIKWkXfrjWOr-Ao_vzQTWB2akUfxxtaupFKLrlQ,1432
 tableauserverclient/models/permissions_item.py,sha256=2WlJOc1Vxkxl-WnAkFaacWsGxUXU9_d85AetSKrKwP0,3731
-tableauserverclient/models/project_item.py,sha256=Mf5maEdKJqk5ojhT_DNmLqL50Ib6u1OKYEDq0oJpeGs,7056
+tableauserverclient/models/project_item.py,sha256=DNxAhkMkRt9MLcMie4w8nuTG4sApIkt618onBEdoM_c,6915
 tableauserverclient/models/property_decorators.py,sha256=eXaYxzXYuHdftlcnqSQOzHYM7OAilETWK8Td2Dtmmuc,4726
 tableauserverclient/models/reference_item.py,sha256=HddG1loGNJU7gB7hBccCjnhagnSEbk4_wY2kuPbNhRQ,534
 tableauserverclient/models/revision_item.py,sha256=fLkcScAgBBiVMCyDPk4aboyZNxrykIavzJP2vkn6Rq0,2787
-tableauserverclient/models/schedule_item.py,sha256=AmodNmh9iKdlGzyEm0pRjdy8-yFSXsIe7xf0Y6oVFVc,10569
+tableauserverclient/models/schedule_item.py,sha256=wSkOz9OUJol_aznOl66ZMDz9Q0Y-LOOc3me8X-ysV28,11324
 tableauserverclient/models/server_info_item.py,sha256=pR_fqqPuiBwpLn0wr4rQ4vxK7gxGJVTtaswzwjslheE,1880
 tableauserverclient/models/site_item.py,sha256=xvXpsR0eEz2ypS-94KJTMS-gusHV1bLomKIhWX7GXrU,42256
 tableauserverclient/models/subscription_item.py,sha256=XkQiAi_gWPBnxtTaB8TgrFa-IDVDtai9H00Ilay0T64,4744
@@ -43,7 +44,7 @@ tableauserverclient/models/tableau_auth.py,sha256=TdkOtRnNRi4p0w_WhBsWqUunNVG9nx
 tableauserverclient/models/tableau_types.py,sha256=1iq1034K1W9ugLAxON_t8n2UxSouiWV_ZEwoHiNM94c,918
 tableauserverclient/models/tag_item.py,sha256=mVfJGZG8PspPM8hBxX38heEQ_Rnp5sSwfwWdLNA-UV0,619
 tableauserverclient/models/target.py,sha256=dVc1SHwo9ZASR8250MhAPODXX_G5UqA4BnK8hykRE6E,263
-tableauserverclient/models/task_item.py,sha256=0DSOZ3aQ6nppD-zVeeK-GKdAxLE0-d-sSazXs7ybH6Q,3466
+tableauserverclient/models/task_item.py,sha256=o0xm588Mc6WGGbYaY0eAxdYog5Z_lfWp1vripK7rKPI,3738
 tableauserverclient/models/user_item.py,sha256=vaQD3nvU7bJVD6t0nkWQFse8UDz8HTp8wh_6WmCjKtM,15776
 tableauserverclient/models/view_item.py,sha256=7OLTLpLXDiYAWi7Tc6vSCkh2Krl7-cvKUwA7iMWZspQ,6777
 tableauserverclient/models/webhook_item.py,sha256=LLf2HQ2Y50Rw-c4dSYyv6MXLbXdij9Iyy261gu9zpv4,2650
@@ -53,8 +54,8 @@ tableauserverclient/server/exceptions.py,sha256=l-O4lcoEeXJC7fLWUanIcZM_Mf8m54uK
 tableauserverclient/server/filter.py,sha256=WZ_dIBuADRZf8VTYcRgn1rulSGUOJq8_uUltq05KkRI,1119
 tableauserverclient/server/pager.py,sha256=rd6rKkoTxP0u3RiOZ3HY9oWKyOcf8aowbHPcs-Ul4D0,2725
 tableauserverclient/server/query.py,sha256=qMweo-N5P_V9z2Or4u_QrStaBbGL6HOg4Y4EDg8uh44,5735
-tableauserverclient/server/request_factory.py,sha256=u8h2EtGKBAN5ELR9Cg_v3bSKvRsMmy4IXVkYp4OZqzQ,59190
-tableauserverclient/server/request_options.py,sha256=xilsnYTsNObCZfwB5ydfzYq7XBkhpvIMWHM67yWQSKY,7105
+tableauserverclient/server/request_factory.py,sha256=br5JwdVFbo9gU2kvg1DUzMnYN31i4UcdLWXwpMheMoY,59350
+tableauserverclient/server/request_options.py,sha256=JiibNhk9QHI1houbtb4NYD4-y9GLxC98iArZJ1E8GUQ,8553
 tableauserverclient/server/server.py,sha256=LhbQOk-lvIBAOF5tTAghYNPFsKJN4Z95SJbuHLAxdKo,8401
 tableauserverclient/server/sort.py,sha256=ikndqXW2r2FeacJzybC2TVcJGn4ktviWgXwPyK-AX-0,208
 tableauserverclient/server/endpoint/__init__.py,sha256=9KGDtgBWlWsWbBQvQV2cbIU-VmHmMqcgtSM7PonpIzg,1141
@@ -63,15 +64,15 @@ tableauserverclient/server/endpoint/custom_views_endpoint.py,sha256=SShsI8TnDe3t
 tableauserverclient/server/endpoint/data_acceleration_report_endpoint.py,sha256=nfC2gXoCke-YXGTiMWGDRBK_lDlLa9Y6hts7w3Zs8cI,1170
 tableauserverclient/server/endpoint/data_alert_endpoint.py,sha256=c6-ICGRVDRQN7ClAgCeJsk6JK4HyBvtQGQVLOzNc4eo,5358
 tableauserverclient/server/endpoint/databases_endpoint.py,sha256=0V6cHwF5E1K1oQ9JKT-rb7t1EFPNwlSKMC2HyqEqYPw,5366
-tableauserverclient/server/endpoint/datasources_endpoint.py,sha256=f51jAj3yr6TssOLygEBmJIZo8y__fRNKbjxnV_yBTDo,20299
+tableauserverclient/server/endpoint/datasources_endpoint.py,sha256=XjoPiejyCGIze6gMO_ALZGWS44vFJ8LxroYr7Xq1OXE,20407
 tableauserverclient/server/endpoint/default_permissions_endpoint.py,sha256=HQSYPIJwVCimuWo4YGYvsc41_-rweLHmJ-tQrWdH-Y8,4386
 tableauserverclient/server/endpoint/dqw_endpoint.py,sha256=TvzjonvIiGtp4EisoBKms1lHOkVTjagQACw6unyY9_8,2418
-tableauserverclient/server/endpoint/endpoint.py,sha256=IZtHZia7aSr2sc1iV8bdtg39kX-IBDsXLoAxKa3y5v8,14425
+tableauserverclient/server/endpoint/endpoint.py,sha256=8-XteqZmfuHDyqR_mGSXKZm9esWbeybaZByHEZoBEac,12743
 tableauserverclient/server/endpoint/exceptions.py,sha256=fh4fFYasqiKd3EPTxriVsmLkRL24wz9UvX94BMRfyLY,2534
 tableauserverclient/server/endpoint/favorites_endpoint.py,sha256=D0MCco9kxaeCShfWOnVt3UpttJRgczJmJKXb3w0jpw4,6701
 tableauserverclient/server/endpoint/fileuploads_endpoint.py,sha256=fh2xH6a8mMcBI14QzodWPBMabK1_9SMDbzZbawz-ZJc,2553
 tableauserverclient/server/endpoint/flow_runs_endpoint.py,sha256=1vwkOrb574natWl-njFOij8xaV32e9RU3-rFbu4bML0,3338
-tableauserverclient/server/endpoint/flows_endpoint.py,sha256=97S15UatgSzdw22Q5ZfhtlVVTvahp7fAtrXt7L28OWg,12898
+tableauserverclient/server/endpoint/flows_endpoint.py,sha256=DIHQUb5LHSerYXsEmaRoiNcdeQ2tU_RaBdr23NnLG2Y,13006
 tableauserverclient/server/endpoint/groups_endpoint.py,sha256=_aSTVy7m3NXSEqgC0cPfJt6KOaPoWprxzz0MD8CsiiY,6640
 tableauserverclient/server/endpoint/jobs_endpoint.py,sha256=P5Hdv1hsNVxd5KdrcNCfR9ZtJ7v3UgrfATCBItVdAxY,3239
 tableauserverclient/server/endpoint/metadata_endpoint.py,sha256=AKnmRNj9U85p__igiuY_vhhipsxNXpQ_9zzNUtTuU9o,5203
@@ -84,14 +85,14 @@ tableauserverclient/server/endpoint/server_info_endpoint.py,sha256=4TtCc7oIp6iEu
 tableauserverclient/server/endpoint/sites_endpoint.py,sha256=lMeVXxm1k32HZK84u7aTys9hUQekb4PE1hlhKFxaZ8c,6694
 tableauserverclient/server/endpoint/subscriptions_endpoint.py,sha256=mMo9M6DF6tAZIab6UY8f_duETezELl9VXEYs5ocAcGY,3280
 tableauserverclient/server/endpoint/tables_endpoint.py,sha256=OJQIarL-IC9mjeu1jfNh9B3UEkB41O51Q53TQNeSJ78,5376
-tableauserverclient/server/endpoint/tasks_endpoint.py,sha256=jHz-d3q-hoxmv9Xg2qPAOzAz9mv0ahHtPSW8IXon0sw,3707
+tableauserverclient/server/endpoint/tasks_endpoint.py,sha256=HjtSGXBGS8Eriaf5bSWySiqLmKQR_rU4Ao3wGz7Xpd8,4060
 tableauserverclient/server/endpoint/users_endpoint.py,sha256=QRoApMyP53nF-AqvC7oLHNcT4VJE8s5ykjUnI5ojmPY,7274
 tableauserverclient/server/endpoint/views_endpoint.py,sha256=GIYPftL5B0YUOb_SisFtfLP0LPIAbbUv24XCi15UH_M,7118
 tableauserverclient/server/endpoint/webhooks_endpoint.py,sha256=-HsbAuKECNcx5EZkqp097PfGHLCNwPRnxbrdzreTpnM,2835
-tableauserverclient/server/endpoint/workbooks_endpoint.py,sha256=65Zv-b0yd4yuh1JAoqbhNlEJM6k2LD6nh1nPQGTdKRc,21734
-tableauserverclient-0.28.dist-info/LICENSE,sha256=MMkY7MguOb4L-WCmmqrVcwg2iwSGaz-RfAMFvXRXwsQ,1074
-tableauserverclient-0.28.dist-info/LICENSE.versioneer,sha256=OYaGozOXk7bUNSm1z577iDYpti8a40XIqqR4lyQ47D8,334
-tableauserverclient-0.28.dist-info/METADATA,sha256=0oM0-poO__vHSlu02Lfa93Lv8lRqYsNn5RI5B6UIRvI,4073
-tableauserverclient-0.28.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-tableauserverclient-0.28.dist-info/top_level.txt,sha256=kBnL39G2RlGqxJSsShDBWG4WZ3NFcWJkv1EGiOfZh4Q,20
-tableauserverclient-0.28.dist-info/RECORD,,
+tableauserverclient/server/endpoint/workbooks_endpoint.py,sha256=_Tfaioe4QBA7VyswtxRu8uL-CzIK0wtslkwj41Wdx_4,21879
+tableauserverclient-0.30.dist-info/LICENSE,sha256=MMkY7MguOb4L-WCmmqrVcwg2iwSGaz-RfAMFvXRXwsQ,1074
+tableauserverclient-0.30.dist-info/LICENSE.versioneer,sha256=OYaGozOXk7bUNSm1z577iDYpti8a40XIqqR4lyQ47D8,334
+tableauserverclient-0.30.dist-info/METADATA,sha256=K7aLh-r1p6dPxb6juSz5gB-fTepGAJOaVzeDABBuk9M,4073
+tableauserverclient-0.30.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+tableauserverclient-0.30.dist-info/top_level.txt,sha256=kBnL39G2RlGqxJSsShDBWG4WZ3NFcWJkv1EGiOfZh4Q,20
+tableauserverclient-0.30.dist-info/RECORD,,

{tableauserverclient-0.28.dist-info → tableauserverclient-0.30.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: bdist_wheel (0.42.0)
 Root-Is-Purelib: true
 Tag: py3-none-any