tableauserverclient 0.29__py3-none-any.whl → 0.30.post0.dev1__py3-none-any.whl

tableauserverclient/__init__.py

@@ -10,6 +10,7 @@ from .models import (
     DailyInterval,
     DataAlertItem,
     DatabaseItem,
+    DataFreshnessPolicyItem,
     DatasourceItem,
     FavoriteItem,
     FlowItem,

tableauserverclient/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-01-14T00:38:52+1100",
+ "date": "2024-06-03T12:52:39-0700",
  "dirty": false,
  "error": null,
- "full-revisionid": "0e46e15fc80c2d4492d9580f111a768536f6afaa",
- "version": "0.29"
+ "full-revisionid": "4018a0ffc01bfa7c5b0024c6f112ced158d420b9",
+ "version": "0.30.post0.dev1"
 }
 '''  # END VERSION_JSON
 

tableauserverclient/models/__init__.py

@@ -5,6 +5,7 @@ from .custom_view_item import CustomViewItem
 from .data_acceleration_report_item import DataAccelerationReportItem
 from .data_alert_item import DataAlertItem
 from .database_item import DatabaseItem
+from .data_freshness_policy_item import DataFreshnessPolicyItem
 from .datasource_item import DatasourceItem
 from .dqw_item import DQWItem
 from .exceptions import UnpopulatedPropertyError

tableauserverclient/models/data_freshness_policy_item.py

@@ -0,0 +1,210 @@
+import xml.etree.ElementTree as ET
+
+from typing import Optional, Union, List
+from tableauserverclient.models.property_decorators import property_is_enum, property_not_nullable
+from .interval_item import IntervalItem
+
+
+class DataFreshnessPolicyItem:
+    class Option:
+        AlwaysLive = "AlwaysLive"
+        SiteDefault = "SiteDefault"
+        FreshEvery = "FreshEvery"
+        FreshAt = "FreshAt"
+
+    class FreshEvery:
+        class Frequency:
+            Minutes = "Minutes"
+            Hours = "Hours"
+            Days = "Days"
+            Weeks = "Weeks"
+
+        def __init__(self, frequency: str, value: int):
+            self.frequency: str = frequency
+            self.value: int = value
+
+        def __repr__(self):
+            return "<FreshEvery frequency={_frequency} value={_value}>".format(**vars(self))
+
+        @property
+        def frequency(self) -> str:
+            return self._frequency
+
+        @frequency.setter
+        @property_is_enum(Frequency)
+        def frequency(self, value: str):
+            self._frequency = value
+
+        @classmethod
+        def from_xml_element(cls, fresh_every_schedule_elem: ET.Element):
+            frequency = fresh_every_schedule_elem.get("frequency", None)
+            value_str = fresh_every_schedule_elem.get("value", None)
+            if (frequency is None) or (value_str is None):
+                return None
+            value = int(value_str)
+            return DataFreshnessPolicyItem.FreshEvery(frequency, value)
+
+    class FreshAt:
+        class Frequency:
+            Day = "Day"
+            Week = "Week"
+            Month = "Month"
+
+        def __init__(self, frequency: str, time: str, timezone, interval_item: Optional[List[str]] = None):
+            self.frequency = frequency
+            self.time = time
+            self.timezone = timezone
+            self.interval_item: Optional[List[str]] = interval_item
+
+        def __repr__(self):
+            return (
+                "<FreshAt frequency={_frequency} time={_time}> timezone={_timezone} " "interval_item={_interval_time}"
+            ).format(**vars(self))
+
+        @property
+        def interval_item(self) -> Optional[List[str]]:
+            return self._interval_item
+
+        @interval_item.setter
+        def interval_item(self, value: List[str]):
+            self._interval_item = value
+
+        @property
+        def time(self):
+            return self._time
+
+        @time.setter
+        @property_not_nullable
+        def time(self, value):
+            self._time = value
+
+        @property
+        def timezone(self) -> str:
+            return self._timezone
+
+        @timezone.setter
+        def timezone(self, value: str):
+            self._timezone = value
+
+        @property
+        def frequency(self) -> str:
+            return self._frequency
+
+        @frequency.setter
+        @property_is_enum(Frequency)
+        def frequency(self, value: str):
+            self._frequency = value
+
+        @classmethod
+        def from_xml_element(cls, fresh_at_schedule_elem: ET.Element, ns):
+            frequency = fresh_at_schedule_elem.get("frequency", None)
+            time = fresh_at_schedule_elem.get("time", None)
+            if (frequency is None) or (time is None):
+                return None
+            timezone = fresh_at_schedule_elem.get("timezone", None)
+            interval = parse_intervals(fresh_at_schedule_elem, frequency, ns)
+            return DataFreshnessPolicyItem.FreshAt(frequency, time, timezone, interval)
+
+    def __init__(self, option: str):
+        self.option = option
+        self.fresh_every_schedule: Optional[DataFreshnessPolicyItem.FreshEvery] = None
+        self.fresh_at_schedule: Optional[DataFreshnessPolicyItem.FreshAt] = None
+
+    def __repr__(self):
+        return "<DataFreshnessPolicy option={_option}>".format(**vars(self))
+
+    @property
+    def option(self) -> str:
+        return self._option
+
+    @option.setter
+    @property_is_enum(Option)
+    def option(self, value: str):
+        self._option = value
+
+    @property
+    def fresh_every_schedule(self) -> Optional[FreshEvery]:
+        return self._fresh_every_schedule
+
+    @fresh_every_schedule.setter
+    def fresh_every_schedule(self, value: FreshEvery):
+        self._fresh_every_schedule = value
+
+    @property
+    def fresh_at_schedule(self) -> Optional[FreshAt]:
+        return self._fresh_at_schedule
+
+    @fresh_at_schedule.setter
+    def fresh_at_schedule(self, value: FreshAt):
+        self._fresh_at_schedule = value
+
+    @classmethod
+    def from_xml_element(cls, data_freshness_policy_elem, ns):
+        option = data_freshness_policy_elem.get("option", None)
+        if option is None:
+            return None
+        data_freshness_policy = DataFreshnessPolicyItem(option)
+
+        fresh_at_schedule = None
+        fresh_every_schedule = None
+        if option == "FreshAt":
+            fresh_at_schedule_elem = data_freshness_policy_elem.find(".//t:freshAtSchedule", namespaces=ns)
+            fresh_at_schedule = DataFreshnessPolicyItem.FreshAt.from_xml_element(fresh_at_schedule_elem, ns)
+            data_freshness_policy.fresh_at_schedule = fresh_at_schedule
+        elif option == "FreshEvery":
+            fresh_every_schedule_elem = data_freshness_policy_elem.find(".//t:freshEverySchedule", namespaces=ns)
+            fresh_every_schedule = DataFreshnessPolicyItem.FreshEvery.from_xml_element(fresh_every_schedule_elem)
+            data_freshness_policy.fresh_every_schedule = fresh_every_schedule
+
+        return data_freshness_policy
+
+
+def parse_intervals(intervals_elem, frequency, ns):
+    interval_elems = intervals_elem.findall(".//t:intervals/t:interval", namespaces=ns)
+    interval = []
+    for interval_elem in interval_elems:
+        interval.extend(interval_elem.attrib.items())
+
+    # No intervals expected for Day frequency
+    if frequency == DataFreshnessPolicyItem.FreshAt.Frequency.Day:
+        return None
+
+    if frequency == DataFreshnessPolicyItem.FreshAt.Frequency.Week:
+        interval_values = [(i[1]).title() for i in interval]
+        return parse_week_intervals(interval_values)
+
+    if frequency == DataFreshnessPolicyItem.FreshAt.Frequency.Month:
+        interval_values = [(i[1]) for i in interval]
+        return parse_month_intervals(interval_values)
+
+
+def parse_week_intervals(interval_values):
+    # Using existing IntervalItem.Day to check valid weekday string
+    if not all(hasattr(IntervalItem.Day, day) for day in interval_values):
+        raise ValueError("Invalid week day defined " + str(interval_values))
+    return interval_values
+
+
+def parse_month_intervals(interval_values):
+    error = "Invalid interval value for a monthly frequency: {}.".format(interval_values)
+
+    # Month interval can have value either only ['LastDay'] or list of dates e.g. ["1", 20", "30"]
+    # First check if the list only have LastDay value. When using LastDay, there shouldn't be
+    # any other values, hence checking the first element of the list is enough.
+    # If the value is not "LastDay", we assume intervals is on list of dates format.
+    # We created this function instead of using existing MonthlyInterval because we allow list of dates interval,
+
+    intervals = []
+    if interval_values[0] == "LastDay":
+        intervals.append(interval_values[0])
+    else:
+        for interval in interval_values:
+            try:
+                if 1 <= int(interval) <= 31:
+                    intervals.append(interval)
+                else:
+                    raise ValueError(error)
+            except ValueError:
+                if interval_values[0] != "LastDay":
+                    raise ValueError(error)
+    return intervals

tableauserverclient/models/interval_item.py

@@ -69,7 +69,7 @@ class HourlyInterval(object):
 
     @interval.setter
     def interval(self, intervals):
-        VALID_INTERVALS = {0.25, 0.5, 1, 2, 4, 6, 8, 12}
+        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):
@@ -136,7 +136,7 @@ class DailyInterval(object):
 
     @interval.setter
     def interval(self, intervals):
-        VALID_INTERVALS = {0.25, 0.5, 1, 2, 4, 6, 8, 12}
+        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

tableauserverclient/models/property_decorators.py

@@ -1,6 +1,7 @@
 import datetime
 import re
 from functools import wraps
+from typing import Any, Container, Optional, Tuple
 
 from tableauserverclient.datetime_helpers import parse_datetime
 
@@ -65,7 +66,7 @@ def property_is_valid_time(func):
     return wrapper
 
 
-def property_is_int(range, allowed=None):
+def property_is_int(range: Tuple[int, int], allowed: Optional[Container[Any]] = None):
     """Takes a range of ints and a list of exemptions to check against
     when setting a property on a model. The range is a tuple of (min, max) and the
     allowed list (empty by default) allows values outside that range.
@@ -89,8 +90,10 @@ def property_is_int(range, allowed=None):
                     raise ValueError(error)
 
             min, max = range
+            if value in allowed:
+                return func(self, value)
 
-            if (value < min or value > max) and (value not in allowed):
+            if value < min or value > max:
                 raise ValueError(error)
 
             return func(self, value)
@@ -144,15 +147,7 @@ def property_is_data_acceleration_config(func):
     def wrapper(self, value):
         if not isinstance(value, dict):
             raise ValueError("{} is not type 'dict', cannot update {})".format(value.__class__.__name__, func.__name__))
-        if len(value) != 4 or not all(
-            attr in value.keys()
-            for attr in (
-                "acceleration_enabled",
-                "accelerate_now",
-                "last_updated_at",
-                "acceleration_status",
-            )
-        ):
+        if len(value) < 2 or not all(attr in value.keys() for attr in ("acceleration_enabled", "accelerate_now")):
             error = "{} should have 2 keys ".format(func.__name__)
             error += "'acceleration_enabled' and 'accelerate_now'"
             error += "instead you have {}".format(value.keys())

tableauserverclient/models/schedule_item.py

@@ -26,6 +26,7 @@ class ScheduleItem(object):
         Subscription = "Subscription"
         DataAcceleration = "DataAcceleration"
         ActiveDirectorySync = "ActiveDirectorySync"
+        System = "System"
 
     class ExecutionOrder:
         Parallel = "Parallel"

tableauserverclient/models/task_item.py

@@ -18,6 +18,7 @@ class TaskItem(object):
     _TASK_TYPE_MAPPING = {
         "RefreshExtractTask": Type.ExtractRefresh,
         "MaterializeViewsTask": Type.DataAcceleration,
+        "RunFlowTask": Type.RunFlow,
     }
 
     def __init__(

tableauserverclient/models/view_item.py

@@ -31,6 +31,10 @@ class ViewItem(object):
         self._workbook_id: Optional[str] = None
         self._permissions: Optional[Callable[[], List[PermissionsRule]]] = None
         self.tags: Set[str] = set()
+        self._data_acceleration_config = {
+            "acceleration_enabled": None,
+            "acceleration_status": None,
+        }
 
     def __str__(self):
         return "<ViewItem {0} '{1}' contentUrl='{2}' project={3}>".format(
@@ -133,6 +137,14 @@ class ViewItem(object):
     def workbook_id(self) -> Optional[str]:
         return self._workbook_id
 
+    @property
+    def data_acceleration_config(self):
+        return self._data_acceleration_config
+
+    @data_acceleration_config.setter
+    def data_acceleration_config(self, value):
+        self._data_acceleration_config = value
+
     @property
     def permissions(self) -> List[PermissionsRule]:
         if self._permissions is None:
@@ -164,6 +176,7 @@ class ViewItem(object):
         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)
+        data_acceleration_config_elem = view_xml.find(".//t:dataAccelerationConfig", 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)
@@ -186,4 +199,25 @@ class ViewItem(object):
             tags = TagItem.from_xml_element(tags_elem, ns)
             view_item.tags = tags
             view_item._initial_tags = copy.copy(tags)
+        if data_acceleration_config_elem is not None:
+            data_acceleration_config = parse_data_acceleration_config(data_acceleration_config_elem)
+            view_item.data_acceleration_config = data_acceleration_config
         return view_item
+
+
+def parse_data_acceleration_config(data_acceleration_elem):
+    data_acceleration_config = dict()
+
+    acceleration_enabled = data_acceleration_elem.get("accelerationEnabled", None)
+    if acceleration_enabled is not None:
+        acceleration_enabled = string_to_bool(acceleration_enabled)
+
+    acceleration_status = data_acceleration_elem.get("accelerationStatus", None)
+
+    data_acceleration_config["acceleration_enabled"] = acceleration_enabled
+    data_acceleration_config["acceleration_status"] = acceleration_status
+    return data_acceleration_config
+
+
+def string_to_bool(s: str) -> bool:
+    return s.lower() == "true"

tableauserverclient/models/workbook_item.py

@@ -17,6 +17,7 @@ from .property_decorators import (
 from .revision_item import RevisionItem
 from .tag_item import TagItem
 from .view_item import ViewItem
+from .data_freshness_policy_item import DataFreshnessPolicyItem
 
 
 class WorkbookItem(object):
@@ -34,7 +35,7 @@ class WorkbookItem(object):
         self._revisions = None
         self._size = None
         self._updated_at = None
-        self._views = None
+        self._views: Optional[Callable[[], List[ViewItem]]] = None
         self.name = name
         self._description = None
         self.owner_id: Optional[str] = None
@@ -49,6 +50,7 @@ class WorkbookItem(object):
             "last_updated_at": None,
             "acceleration_status": None,
         }
+        self.data_freshness_policy = None
         self._permissions = None
 
         return None
@@ -91,6 +93,10 @@ class WorkbookItem(object):
     def description(self) -> Optional[str]:
         return self._description
 
+    @description.setter
+    def description(self, value: str):
+        self._description = value
+
     @property
     def id(self) -> Optional[str]:
         return self._id
@@ -162,6 +168,10 @@ class WorkbookItem(object):
             # We had views included in a WorkbookItem response
             return self._views
 
+    @views.setter
+    def views(self, value):
+        self._views = value
+
     @property
     def data_acceleration_config(self):
         return self._data_acceleration_config
@@ -171,6 +181,15 @@ class WorkbookItem(object):
     def data_acceleration_config(self, value):
         self._data_acceleration_config = value
 
+    @property
+    def data_freshness_policy(self):
+        return self._data_freshness_policy
+
+    @data_freshness_policy.setter
+    # @property_is_data_freshness_policy
+    def data_freshness_policy(self, value):
+        self._data_freshness_policy = value
+
     @property
     def revisions(self) -> List[RevisionItem]:
         if self._revisions is None:
@@ -217,8 +236,9 @@ class WorkbookItem(object):
                 project_name,
                 owner_id,
                 _,
-                _,
+                views,
                 data_acceleration_config,
+                data_freshness_policy,
             ) = self._parse_element(workbook_xml, ns)
 
             self._set_values(
@@ -235,8 +255,9 @@ class WorkbookItem(object):
                 project_name,
                 owner_id,
                 None,
-                None,
+                views,
                 data_acceleration_config,
+                data_freshness_policy,
             )
 
         return self
@@ -258,6 +279,7 @@ class WorkbookItem(object):
         tags,
         views,
         data_acceleration_config,
+        data_freshness_policy,
     ):
         if id is not None:
             self._id = id
@@ -286,10 +308,12 @@ class WorkbookItem(object):
         if tags:
             self.tags = tags
             self._initial_tags = copy.copy(tags)
-        if views:
+        if views is not None:
             self._views = views
         if data_acceleration_config is not None:
             self.data_acceleration_config = data_acceleration_config
+        if data_freshness_policy is not None:
+            self.data_freshness_policy = data_freshness_policy
 
     @classmethod
     def from_response(cls, resp: str, ns: Dict[str, str]) -> List["WorkbookItem"]:
@@ -356,6 +380,11 @@ class WorkbookItem(object):
         if data_acceleration_elem is not None:
             data_acceleration_config = parse_data_acceleration_config(data_acceleration_elem)
 
+        data_freshness_policy = None
+        data_freshness_policy_elem = workbook_xml.find(".//t:dataFreshnessPolicy", namespaces=ns)
+        if data_freshness_policy_elem is not None:
+            data_freshness_policy = DataFreshnessPolicyItem.from_xml_element(data_freshness_policy_elem, ns)
+
         return (
             id,
             name,
@@ -372,6 +401,7 @@ class WorkbookItem(object):
             tags,
             views,
             data_acceleration_config,
+            data_freshness_policy,
         )
 
 

tableauserverclient/server/endpoint/__init__.py

@@ -10,6 +10,7 @@ from .favorites_endpoint import Favorites
 from .fileuploads_endpoint import Fileuploads
 from .flow_runs_endpoint import FlowRuns
 from .flows_endpoint import Flows
+from .flow_task_endpoint import FlowTasks
 from .groups_endpoint import Groups
 from .jobs_endpoint import Jobs
 from .metadata_endpoint import Metadata

tableauserverclient/server/endpoint/datasources_endpoint.py

@@ -1,4 +1,4 @@
-import cgi
+from email.message import Message
 import copy
 import json
 import io
@@ -437,14 +437,16 @@ class Datasources(QuerysetEndpoint):
             url += "?includeExtract=False"
 
         with closing(self.get_request(url, parameters={"stream": True})) as server_response:
-            _, params = cgi.parse_header(server_response.headers["Content-Disposition"])
+            m = Message()
+            m["Content-Disposition"] = server_response.headers["Content-Disposition"]
+            params = m.get_filename(failobj="")
             if isinstance(filepath, io_types_w):
                 for chunk in server_response.iter_content(1024):  # 1KB
                     filepath.write(chunk)
                 return_path = filepath
             else:
                 params = fix_filename(params)
-                filename = to_filename(os.path.basename(params["filename"]))
+                filename = to_filename(os.path.basename(params))
                 download_path = make_download_path(filepath, filename)
                 with open(download_path, "wb") as f:
                     for chunk in server_response.iter_content(1024):  # 1KB

tableauserverclient/server/endpoint/endpoint.py

@@ -1,5 +1,3 @@
-from threading import Thread
-from time import sleep
 from tableauserverclient import datetime_helpers as datetime
 
 from packaging.version import Version
@@ -76,55 +74,20 @@ class Endpoint(object):
         return parameters
 
     def _blocking_request(self, method, url, parameters={}) -> Optional[Union["Response", Exception]]:
-        self.async_response = None
         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=None
     ) -> Optional[Union["Response", Exception]]:
-        try:
-            request_thread = Thread(target=self._blocking_request, args=(method, url, parameters))
-            request_thread.start()
-        except Exception as e:
-            logger.debug("Error starting server request on separate thread: {}".format(e))
-            return None
-        seconds = 0.05
-        minutes = 0
-        last_log_minute = 0
-        sleep(seconds)
-        if self.async_response is not None:
-            # a quick return for any immediate responses
-            return self.async_response
-        timed_out: bool = request_timeout is not None and seconds > request_timeout
-        while (self.async_response is None) and not timed_out:
-            sleep(DELAY_SLEEP_SECONDS)
-            seconds = seconds + DELAY_SLEEP_SECONDS
-            minutes = int(seconds / 60)
-            last_log_minute = self.log_wait_time(minutes, last_log_minute, url)
-        return self.async_response
-
-    def log_wait_time(self, minutes, last_log_minute, url) -> int:
-        logger.debug("{} Waiting....".format(datetime.timestamp()))
-        if minutes > last_log_minute:  # detailed log message ~every minute
-            logger.info("[{}] Waiting ({} minutes so far) for request to {}".format(datetime.timestamp(), minutes, url))
-            last_log_minute = minutes
-        else:
-            logger.debug("[{}] Waiting for request to {}".format(datetime.timestamp(), url))
-        return last_log_minute
+        return self._blocking_request(method, url, parameters)
 
     def _make_request(
         self,

tableauserverclient/server/endpoint/flow_task_endpoint.py

@@ -0,0 +1,29 @@
+import logging
+from typing import List, Optional, Tuple, TYPE_CHECKING
+
+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 FlowTasks(Endpoint):
+    @property
+    def baseurl(self) -> str:
+        return "{0}/sites/{1}/tasks/flows".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+
+    @api(version="3.22")
+    def create(self, flow_item: TaskItem) -> TaskItem:
+        if not flow_item:
+            error = "No flow provided"
+            raise ValueError(error)
+        logger.info("Creating an flow task %s", flow_item)
+        url = self.baseurl
+        create_req = RequestFactory.FlowTask.create_flow_task_req(flow_item)
+        server_response = self.post_request(url, create_req)
+        return server_response.content

tableauserverclient/server/endpoint/flows_endpoint.py

@@ -1,4 +1,4 @@
-import cgi
+from email.message import Message
 import copy
 import io
 import logging
@@ -120,14 +120,16 @@ class Flows(QuerysetEndpoint):
         url = "{0}/{1}/content".format(self.baseurl, flow_id)
 
         with closing(self.get_request(url, parameters={"stream": True})) as server_response:
-            _, params = cgi.parse_header(server_response.headers["Content-Disposition"])
+            m = Message()
+            m["Content-Disposition"] = server_response.headers["Content-Disposition"]
+            params = m.get_filename(failobj="")
             if isinstance(filepath, io_types_w):
                 for chunk in server_response.iter_content(1024):  # 1KB
                     filepath.write(chunk)
                 return_path = filepath
             else:
                 params = fix_filename(params)
-                filename = to_filename(os.path.basename(params["filename"]))
+                filename = to_filename(os.path.basename(params))
                 download_path = make_download_path(filepath, filename)
                 with open(download_path, "wb") as f:
                     for chunk in server_response.iter_content(1024):  # 1KB

tableauserverclient/server/endpoint/workbooks_endpoint.py

@@ -1,4 +1,4 @@
-import cgi
+from email.message import Message
 import copy
 import io
 import logging
@@ -137,7 +137,12 @@ class Workbooks(QuerysetEndpoint):
 
     # Update workbook
     @api(version="2.0")
-    def update(self, workbook_item: WorkbookItem) -> WorkbookItem:
+    @parameter_added_in(include_view_acceleration_status="3.22")
+    def update(
+        self,
+        workbook_item: WorkbookItem,
+        include_view_acceleration_status: bool = False,
+    ) -> WorkbookItem:
         if not workbook_item.id:
             error = "Workbook item missing ID. Workbook must be retrieved from server first."
             raise MissingRequiredFieldError(error)
@@ -146,6 +151,9 @@ class Workbooks(QuerysetEndpoint):
 
         # Update the workbook itself
         url = "{0}/{1}".format(self.baseurl, workbook_item.id)
+        if include_view_acceleration_status:
+            url += "?includeViewAccelerationStatus=True"
+
         update_req = RequestFactory.Workbook.update_req(workbook_item)
         server_response = self.put_request(url, update_req)
         logger.info("Updated workbook item (ID: {0})".format(workbook_item.id))
@@ -483,14 +491,16 @@ class Workbooks(QuerysetEndpoint):
             url += "?includeExtract=False"
 
         with closing(self.get_request(url, parameters={"stream": True})) as server_response:
-            _, params = cgi.parse_header(server_response.headers["Content-Disposition"])
+            m = Message()
+            m["Content-Disposition"] = server_response.headers["Content-Disposition"]
+            params = m.get_filename(failobj="")
             if isinstance(filepath, io_types_w):
                 for chunk in server_response.iter_content(1024):  # 1KB
                     filepath.write(chunk)
                 return_path = filepath
             else:
                 params = fix_filename(params)
-                filename = to_filename(os.path.basename(params["filename"]))
+                filename = to_filename(os.path.basename(params))
                 download_path = make_download_path(filepath, filename)
                 with open(download_path, "wb") as f:
                     for chunk in server_response.iter_content(1024):  # 1KB

tableauserverclient/server/pager.py

@@ -47,7 +47,11 @@ class Pager(object):
 
         # Get the rest on demand as a generator
         while self._count < last_pagination_item.total_available:
-            if len(current_item_list) == 0:
+            if (
+                len(current_item_list) == 0
+                and (last_pagination_item.page_number * last_pagination_item.page_size)
+                < last_pagination_item.total_available
+            ):
                 current_item_list, last_pagination_item = self._load_next_page(last_pagination_item)
 
             try:

tableauserverclient/server/request_factory.py

@@ -57,6 +57,11 @@ def _add_hiddenview_element(views_element, view_name):
     view_element.attrib["hidden"] = "true"
 
 
+def _add_view_element(views_element, view_id):
+    view_element = ET.SubElement(views_element, "view")
+    view_element.attrib["id"] = view_id
+
+
 def _add_credentials_element(parent_element, connection_credentials):
     credentials_element = ET.SubElement(parent_element, "connectionCredentials")
     if connection_credentials.password is None or connection_credentials.name is None:
@@ -911,6 +916,9 @@ class WorkbookRequest(object):
             for connection in connections:
                 _add_connections_element(connections_element, connection)
 
+        if workbook_item.description is not None:
+            workbook_element.attrib["description"] = workbook_item.description
+
         if hidden_views is not None:
             import warnings
 
@@ -941,16 +949,61 @@ class WorkbookRequest(object):
         if workbook_item.owner_id:
             owner_element = ET.SubElement(workbook_element, "owner")
             owner_element.attrib["id"] = workbook_item.owner_id
-        if workbook_item.data_acceleration_config["acceleration_enabled"] is not None:
+        if workbook_item._views is not None:
+            views_element = ET.SubElement(workbook_element, "views")
+            for view in workbook_item.views:
+                _add_view_element(views_element, view.id)
+        if workbook_item.data_acceleration_config:
             data_acceleration_config = workbook_item.data_acceleration_config
             data_acceleration_element = ET.SubElement(workbook_element, "dataAccelerationConfig")
-            data_acceleration_element.attrib["accelerationEnabled"] = str(
-                data_acceleration_config["acceleration_enabled"]
-            ).lower()
+            if data_acceleration_config["acceleration_enabled"] is not None:
+                data_acceleration_element.attrib["accelerationEnabled"] = str(
+                    data_acceleration_config["acceleration_enabled"]
+                ).lower()
             if data_acceleration_config["accelerate_now"] is not None:
                 data_acceleration_element.attrib["accelerateNow"] = str(
                     data_acceleration_config["accelerate_now"]
                 ).lower()
+        if workbook_item.data_freshness_policy is not None:
+            data_freshness_policy_config = workbook_item.data_freshness_policy
+            data_freshness_policy_element = ET.SubElement(workbook_element, "dataFreshnessPolicy")
+            data_freshness_policy_element.attrib["option"] = str(data_freshness_policy_config.option)
+            # Fresh Every Schedule
+            if data_freshness_policy_config.option == "FreshEvery":
+                if data_freshness_policy_config.fresh_every_schedule is not None:
+                    fresh_every_element = ET.SubElement(data_freshness_policy_element, "freshEverySchedule")
+                    fresh_every_element.attrib[
+                        "frequency"
+                    ] = data_freshness_policy_config.fresh_every_schedule.frequency
+                    fresh_every_element.attrib["value"] = str(data_freshness_policy_config.fresh_every_schedule.value)
+                else:
+                    raise ValueError(f"data_freshness_policy_config.fresh_every_schedule must be populated.")
+            # Fresh At Schedule
+            if data_freshness_policy_config.option == "FreshAt":
+                if data_freshness_policy_config.fresh_at_schedule is not None:
+                    fresh_at_element = ET.SubElement(data_freshness_policy_element, "freshAtSchedule")
+                    frequency = data_freshness_policy_config.fresh_at_schedule.frequency
+                    fresh_at_element.attrib["frequency"] = frequency
+                    fresh_at_element.attrib["time"] = str(data_freshness_policy_config.fresh_at_schedule.time)
+                    fresh_at_element.attrib["timezone"] = str(data_freshness_policy_config.fresh_at_schedule.timezone)
+                    intervals = data_freshness_policy_config.fresh_at_schedule.interval_item
+                    # Fresh At Schedule intervals if Frequency is Week or Month
+                    if frequency != DataFreshnessPolicyItem.FreshAt.Frequency.Day:
+                        if intervals is not None:
+                            # if intervals is not None or frequency != DataFreshnessPolicyItem.FreshAt.Frequency.Day:
+                            intervals_element = ET.SubElement(fresh_at_element, "intervals")
+                            for interval in intervals:
+                                expression = IntervalItem.Occurrence.WeekDay
+                                if frequency == DataFreshnessPolicyItem.FreshAt.Frequency.Month:
+                                    expression = IntervalItem.Occurrence.MonthDay
+                                single_interval_element = ET.SubElement(intervals_element, "interval")
+                                single_interval_element.attrib[expression] = interval
+                        else:
+                            raise ValueError(
+                                f"fresh_at_schedule.interval_item must be populated for " f"Week & Month frequency."
+                            )
+                else:
+                    raise ValueError(f"data_freshness_policy_config.fresh_at_schedule must be populated.")
 
         return ET.tostring(xml_request)
 
@@ -1061,6 +1114,40 @@ class TaskRequest(object):
         return ET.tostring(xml_request)
 
 
+class FlowTaskRequest(object):
+    @_tsrequest_wrapped
+    def create_flow_task_req(self, xml_request: ET.Element, flow_item: "TaskItem") -> bytes:
+        flow_element = ET.SubElement(xml_request, "runFlow")
+
+        # Main attributes
+        flow_element.attrib["type"] = flow_item.task_type
+
+        if flow_item.target is not None:
+            target_element = ET.SubElement(flow_element, flow_item.target.type)
+            target_element.attrib["id"] = flow_item.target.id
+
+        if flow_item.schedule_item is None:
+            return ET.tostring(xml_request)
+
+        # Schedule attributes
+        schedule_element = ET.SubElement(xml_request, "schedule")
+
+        interval_item = flow_item.schedule_item.interval_item
+        schedule_element.attrib["frequency"] = interval_item._frequency
+        frequency_element = ET.SubElement(schedule_element, "frequencyDetails")
+        frequency_element.attrib["start"] = str(interval_item.start_time)
+        if hasattr(interval_item, "end_time") and interval_item.end_time is not None:
+            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():  # type: ignore
+                expression, value = interval
+                single_interval_element = ET.SubElement(intervals_element, "interval")
+                single_interval_element.attrib[expression] = value
+
+        return ET.tostring(xml_request)
+
+
 class SubscriptionRequest(object):
     @_tsrequest_wrapped
     def create_req(self, xml_request: ET.Element, subscription_item: "SubscriptionItem") -> bytes:
@@ -1200,6 +1287,7 @@ class RequestFactory(object):
     Favorite = FavoriteRequest()
     Fileupload = FileuploadRequest()
     Flow = FlowRequest()
+    FlowTask = FlowTaskRequest()
     Group = GroupRequest()
     Metric = MetricRequest()
     Permission = PermissionRequest()

tableauserverclient/server/request_options.py

@@ -1,3 +1,7 @@
+import sys
+
+from typing_extensions import Self
+
 from tableauserverclient.models.property_decorators import property_is_int
 import logging
 
@@ -152,17 +156,27 @@ class _FilterOptionsBase(RequestOptionsBase):
 
     def __init__(self):
         self.view_filters = []
+        self.view_parameters = []
 
     def get_query_params(self):
         raise NotImplementedError()
 
-    def vf(self, name, value):
+    def vf(self, name: str, value: str) -> Self:
+        """Apply a filter to the view for a filter that is a normal column
+        within the view."""
         self.view_filters.append((name, value))
         return self
 
-    def _append_view_filters(self, params):
+    def parameter(self, name: str, value: str) -> Self:
+        """Apply a filter based on a parameter within the workbook."""
+        self.view_parameters.append((name, value))
+        return self
+
+    def _append_view_filters(self, params) -> None:
         for name, value in self.view_filters:
             params["vf_" + name] = value
+        for name, value in self.view_parameters:
+            params[name] = value
 
 
 class CSVRequestOptions(_FilterOptionsBase):
@@ -261,11 +275,13 @@ class PDFRequestOptions(_FilterOptionsBase):
         Portrait = "portrait"
         Landscape = "landscape"
 
-    def __init__(self, page_type=None, orientation=None, maxage=-1):
+    def __init__(self, page_type=None, orientation=None, maxage=-1, viz_height=None, viz_width=None):
         super(PDFRequestOptions, self).__init__()
         self.page_type = page_type
         self.orientation = orientation
         self.max_age = maxage
+        self.viz_height = viz_height
+        self.viz_width = viz_width
 
     @property
     def max_age(self):
@@ -276,6 +292,24 @@ class PDFRequestOptions(_FilterOptionsBase):
     def max_age(self, value):
         self._max_age = value
 
+    @property
+    def viz_height(self):
+        return self._viz_height
+
+    @viz_height.setter
+    @property_is_int(range=(0, sys.maxsize), allowed=(None,))
+    def viz_height(self, value):
+        self._viz_height = value
+
+    @property
+    def viz_width(self):
+        return self._viz_width
+
+    @viz_width.setter
+    @property_is_int(range=(0, sys.maxsize), allowed=(None,))
+    def viz_width(self, value):
+        self._viz_width = value
+
     def get_query_params(self):
         params = {}
         if self.page_type:
@@ -287,6 +321,16 @@ class PDFRequestOptions(_FilterOptionsBase):
         if self.max_age != -1:
             params["maxAge"] = self.max_age
 
+        # XOR. Either both are None or both are not None.
+        if (self.viz_height is None) ^ (self.viz_width is None):
+            raise ValueError("viz_height and viz_width must be specified together")
+
+        if self.viz_height is not None:
+            params["vizHeight"] = self.viz_height
+
+        if self.viz_width is not None:
+            params["vizWidth"] = self.viz_width
+
         self._append_view_filters(params)
 
         return params

tableauserverclient/server/server.py

@@ -25,6 +25,7 @@ from .endpoint import (
     Databases,
     Tables,
     Flows,
+    FlowTasks,
     Webhooks,
     DataAccelerationReport,
     Favorites,
@@ -82,6 +83,7 @@ class Server(object):
         self.datasources = Datasources(self)
         self.favorites = Favorites(self)
         self.flows = Flows(self)
+        self.flow_tasks = FlowTasks(self)
         self.projects = Projects(self)
         self.schedules = Schedules(self)
         self.server_info = ServerInfo(self)

{tableauserverclient-0.29.dist-info → tableauserverclient-0.30.post0.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tableauserverclient
-Version: 0.29
+Version: 0.30.post0.dev1
 Summary: A Python module for working with the Tableau Server REST API.
 Author-email: Tableau <github@tableau.com>
 License: The MIT License (MIT)
@@ -41,6 +41,7 @@ Requires-Dist: defusedxml >=0.7.1
 Requires-Dist: packaging >=23.1
 Requires-Dist: requests >=2.31
 Requires-Dist: urllib3 ==2.0.7
+Requires-Dist: typing-extensions >=4.0.1
 Provides-Extra: test
 Requires-Dist: argparse ; extra == 'test'
 Requires-Dist: black ==23.7 ; extra == 'test'

{tableauserverclient-0.29.dist-info → tableauserverclient-0.30.post0.dev1.dist-info}/RECORD

@@ -1,5 +1,5 @@
-tableauserverclient/__init__.py,sha256=hDjLTdwXPmQj4BQBRdUcnP7XdhT7apJ_c7JAPyyYZ7Y,1096
-tableauserverclient/_version.py,sha256=KhL5CD7tzLBzduk7x_vggt-OGe_KkxkcgCnLbAQjNho,496
+tableauserverclient/__init__.py,sha256=3pYu_AmAPRRuMREy0Uq5Dk9MTFX9tIKa4Vc-j7q8iLI,1125
+tableauserverclient/_version.py,sha256=jhLMneVfFrXy4GLLWUM8iJQL5D7Ngdn0QaWQhKzlIKA,507
 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
@@ -10,13 +10,14 @@ tableauserverclient/helpers/__init__.py,sha256=llpqF9zV5dsP5hQt8dyop33Op5OzGmxW0
 tableauserverclient/helpers/headers.py,sha256=Pg-ZWSgV2Yp813BV1Tzo8F2Hn4P01zscla2RRM4yqNk,411
 tableauserverclient/helpers/logging.py,sha256=5q_oR3wERHVXFXY6XDnLYML5-HdAPJTmqhH9IZg4VfY,113
 tableauserverclient/helpers/strings.py,sha256=HRTP31HIdD3gFxDDHuBsmOl_8cLdh8fa3xLALgYsUAQ,1563
-tableauserverclient/models/__init__.py,sha256=NfVfRDeU8b6zTQ7wzkorhvuGIPabym8lXvNiyEX_AVg,1620
+tableauserverclient/models/__init__.py,sha256=odiSv68Ct4G93dSKuhaq3dK0PuL2lF3JGrYedaaLJ1s,1684
 tableauserverclient/models/column_item.py,sha256=gV2r7xOVmcn9UnMXFOe9_ORZ85oha1KtIH-crKUhgN4,1972
 tableauserverclient/models/connection_credentials.py,sha256=8Wa8B_-cB3INFUup-Pyd5znsUD5opgYYH5TfipCzKTU,1559
 tableauserverclient/models/connection_item.py,sha256=BiLrjWY42EtkAyh2_3juo31rYW9YZN1e3uOXMXIaslY,4743
 tableauserverclient/models/custom_view_item.py,sha256=Gr2lYgBU1zUfCoaXHhqTzWDspmL33UqOxlt48Y8yaGg,5782
 tableauserverclient/models/data_acceleration_report_item.py,sha256=5Z18-fppR_lnAyPKHwxi4gOP6kqcYX3Q3RdwiD4Zy94,3402
 tableauserverclient/models/data_alert_item.py,sha256=sJpncsKY1BY-tFJKDpX7xaHy6aGvELWrorsILJxr3lI,6458
+tableauserverclient/models/data_freshness_policy_item.py,sha256=p5iyGHl-juDM3ARl9tWr3i_LnpzalxUTRoDBP6FdTMo,7639
 tableauserverclient/models/database_item.py,sha256=SAwoxsgeowwFN20zGt3-226kJabk0M2tqbVLQthvmRs,8043
 tableauserverclient/models/datasource_item.py,sha256=ZZZvYfzg6gD7DlZWzfEJ3VBQBMYADJ9GeoWV02F7Z8E,11944
 tableauserverclient/models/dqw_item.py,sha256=MFpxSP6vSzpjh5GLNrom--Sbi8iLwuGLuAda8KHiIa8,3718
@@ -26,16 +27,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=yDIytwU53_OhN0nytGM_GObEpmqWVeLqh3iyAbk3ZE0,9049
+tableauserverclient/models/interval_item.py,sha256=NZbGNuPmFI6NhEZWZVAlWfIFbsnIYbcvxvvv9yvgfV8,9057
 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=DNxAhkMkRt9MLcMie4w8nuTG4sApIkt618onBEdoM_c,6915
-tableauserverclient/models/property_decorators.py,sha256=eXaYxzXYuHdftlcnqSQOzHYM7OAilETWK8Td2Dtmmuc,4726
+tableauserverclient/models/property_decorators.py,sha256=W5EtN7bqDHrpLQF63i1cGOhPUJi0RzMJ7qmIlJVrGuE,4711
 tableauserverclient/models/reference_item.py,sha256=HddG1loGNJU7gB7hBccCjnhagnSEbk4_wY2kuPbNhRQ,534
 tableauserverclient/models/revision_item.py,sha256=fLkcScAgBBiVMCyDPk4aboyZNxrykIavzJP2vkn6Rq0,2787
-tableauserverclient/models/schedule_item.py,sha256=wSkOz9OUJol_aznOl66ZMDz9Q0Y-LOOc3me8X-ysV28,11324
+tableauserverclient/models/schedule_item.py,sha256=Tr4uANbrE5X6gQWiN7VR3MzTYTmKQktgKTOuk3hoKeU,11350
 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
@@ -44,35 +45,36 @@ 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=o0xm588Mc6WGGbYaY0eAxdYog5Z_lfWp1vripK7rKPI,3738
+tableauserverclient/models/task_item.py,sha256=EHVJo6NyORC_NZ0NFZTt8ylRBCeO6LFxI1Ubf15L2zo,3775
 tableauserverclient/models/user_item.py,sha256=vaQD3nvU7bJVD6t0nkWQFse8UDz8HTp8wh_6WmCjKtM,15776
-tableauserverclient/models/view_item.py,sha256=7OLTLpLXDiYAWi7Tc6vSCkh2Krl7-cvKUwA7iMWZspQ,6777
+tableauserverclient/models/view_item.py,sha256=OcZqrCJt0cjz1bSUUdLIseOYeDfo4ji4UWkv11el6Bc,8106
 tableauserverclient/models/webhook_item.py,sha256=LLf2HQ2Y50Rw-c4dSYyv6MXLbXdij9Iyy261gu9zpv4,2650
-tableauserverclient/models/workbook_item.py,sha256=x-qRFLAkVKQzd-PFYTkfuzYBkMcW3EOvc6Zx-iVWa3U,12974
+tableauserverclient/models/workbook_item.py,sha256=w6RVKOPFJ9NEmz7OG0SuKw_8FrTE4rWLKw4JkHl1lag,14118
 tableauserverclient/server/__init__.py,sha256=ZyvucBvBQMPyTVW7oDHl4W9NWuaSVSMfN9cTcSQRmKw,406
 tableauserverclient/server/exceptions.py,sha256=l-O4lcoEeXJC7fLWUanIcZM_Mf8m54uK3NQuKNj3RCg,183
 tableauserverclient/server/filter.py,sha256=WZ_dIBuADRZf8VTYcRgn1rulSGUOJq8_uUltq05KkRI,1119
-tableauserverclient/server/pager.py,sha256=rd6rKkoTxP0u3RiOZ3HY9oWKyOcf8aowbHPcs-Ul4D0,2725
+tableauserverclient/server/pager.py,sha256=JLud4Q6tyzfcoIQ5ykSL_veTuvQag-NDNfrPvoC3Bd0,2900
 tableauserverclient/server/query.py,sha256=qMweo-N5P_V9z2Or4u_QrStaBbGL6HOg4Y4EDg8uh44,5735
-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/request_factory.py,sha256=DnZt4kYUtOmWsZxjitvxVnslTaufOapuD5iLsxWUuyc,64606
+tableauserverclient/server/request_options.py,sha256=_eWeWZH9dIv0nPU2hCVjL99kIV56H2q8cm22a088iiM,9982
+tableauserverclient/server/server.py,sha256=8XOze5vSEVY9Nl0WOeyYljbg2i4Yp-_znlKepCvm3Es,8458
 tableauserverclient/server/sort.py,sha256=ikndqXW2r2FeacJzybC2TVcJGn4ktviWgXwPyK-AX-0,208
-tableauserverclient/server/endpoint/__init__.py,sha256=9KGDtgBWlWsWbBQvQV2cbIU-VmHmMqcgtSM7PonpIzg,1141
+tableauserverclient/server/endpoint/__init__.py,sha256=GcWWEKuMPdqHY2OtYYpc8LF3qkMq3m65k9DhTSqenu8,1183
 tableauserverclient/server/endpoint/auth_endpoint.py,sha256=EOGGlGHWUZRN0SFBlYnEWUSwCH1lrB0Zfv4VWdd7HQs,5139
 tableauserverclient/server/endpoint/custom_views_endpoint.py,sha256=SShsI8TnDe3tPXCrCsjs3Oy5Ym4j-QrcDXUfZ7rF9Y4,4542
 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=XjoPiejyCGIze6gMO_ALZGWS44vFJ8LxroYr7Xq1OXE,20407
+tableauserverclient/server/endpoint/datasources_endpoint.py,sha256=6EvZc-mrOZo_qlFORBPVRzWF4srDEBdmFgw-0osxbH8,20489
 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=jjZbvukrkomHQeAJVFbLBJgq7is0EA6a76Xzr4kCxo8,14498
+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=DIHQUb5LHSerYXsEmaRoiNcdeQ2tU_RaBdr23NnLG2Y,13006
+tableauserverclient/server/endpoint/flow_task_endpoint.py,sha256=j3snbRiYAPkI3FwhGG-CxKogHXP3SY59ep74YPrutpw,1113
+tableauserverclient/server/endpoint/flows_endpoint.py,sha256=cVboeR4IZa0Ck8OvYHkzpNzUJTvYgu7TzmF4Fd6bP20,13088
 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
@@ -89,10 +91,10 @@ tableauserverclient/server/endpoint/tasks_endpoint.py,sha256=HjtSGXBGS8Eriaf5bSW
 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=_Tfaioe4QBA7VyswtxRu8uL-CzIK0wtslkwj41Wdx_4,21879
-tableauserverclient-0.29.dist-info/LICENSE,sha256=MMkY7MguOb4L-WCmmqrVcwg2iwSGaz-RfAMFvXRXwsQ,1074
-tableauserverclient-0.29.dist-info/LICENSE.versioneer,sha256=OYaGozOXk7bUNSm1z577iDYpti8a40XIqqR4lyQ47D8,334
-tableauserverclient-0.29.dist-info/METADATA,sha256=rLRiTqsKYowp9yVGVtZGf7_yAzrfgeLb6vULz93_V8M,4073
-tableauserverclient-0.29.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-tableauserverclient-0.29.dist-info/top_level.txt,sha256=kBnL39G2RlGqxJSsShDBWG4WZ3NFcWJkv1EGiOfZh4Q,20
-tableauserverclient-0.29.dist-info/RECORD,,
+tableauserverclient/server/endpoint/workbooks_endpoint.py,sha256=xWG8DJQFHLsp0DoUgE-sNdjTAy-aVFBfYASRizhdV88,22208
+tableauserverclient-0.30.post0.dev1.dist-info/LICENSE,sha256=MMkY7MguOb4L-WCmmqrVcwg2iwSGaz-RfAMFvXRXwsQ,1074
+tableauserverclient-0.30.post0.dev1.dist-info/LICENSE.versioneer,sha256=OYaGozOXk7bUNSm1z577iDYpti8a40XIqqR4lyQ47D8,334
+tableauserverclient-0.30.post0.dev1.dist-info/METADATA,sha256=3MUzWOn6XvZdbPd9-0Z-zKUVKvgIXdrl-QxI6HQ8RyA,4125
+tableauserverclient-0.30.post0.dev1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+tableauserverclient-0.30.post0.dev1.dist-info/top_level.txt,sha256=kBnL39G2RlGqxJSsShDBWG4WZ3NFcWJkv1EGiOfZh4Q,20
+tableauserverclient-0.30.post0.dev1.dist-info/RECORD,,

{tableauserverclient-0.29.dist-info → tableauserverclient-0.30.post0.dev1.dist-info}/WHEEL

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