tableauserverclient 0.30__tar.gz → 0.30.post0.dev1__tar.gz

{tableauserverclient-0.30 → tableauserverclient-0.30.post0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tableauserverclient
-Version: 0.30
+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.30 → tableauserverclient-0.30.post0.dev1}/pyproject.toml

@@ -16,6 +16,7 @@ dependencies = [
     'packaging>=23.1',   # latest as at 7/31/23
     'requests>=2.31',  # latest as at 7/31/23
     'urllib3==2.0.7',  # latest as at 7/31/23
+    'typing_extensions>=4.0.1',
 ]
 requires-python = ">=3.7"
 classifiers = [

tableauserverclient-0.30.post0.dev1/samples/update_workbook_data_acceleration.py

@@ -0,0 +1,109 @@
+####
+# This script demonstrates how to update workbook data acceleration  using the Tableau
+# Server Client.
+#
+# To run the script, you must have installed Python 3.7 or later.
+####
+
+
+import argparse
+import logging
+
+import tableauserverclient as TSC
+from tableauserverclient import IntervalItem
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Creates sample schedules for each type of frequency.")
+    # Common options; please keep those in sync across all samples
+    parser.add_argument("--server", "-s", help="server address")
+    parser.add_argument("--site", "-S", help="site name")
+    parser.add_argument("--token-name", "-p", help="name of the personal access token used to sign into the server")
+    parser.add_argument("--token-value", "-v", help="value of the personal access token used to sign into the server")
+    parser.add_argument(
+        "--logging-level",
+        "-l",
+        choices=["debug", "info", "error"],
+        default="error",
+        help="desired logging level (set to error by default)",
+    )
+    # Options specific to this sample:
+    # This sample has no additional options, yet. If you add some, please add them here
+
+    args = parser.parse_args()
+
+    # Set logging level based on user input, or error by default
+    logging_level = getattr(logging, args.logging_level.upper())
+    logging.basicConfig(level=logging_level)
+
+    tableau_auth = TSC.PersonalAccessTokenAuth(args.token_name, args.token_value, site_id=args.site)
+    server = TSC.Server(args.server, use_server_version=False)
+    server.add_http_options({"verify": False})
+    server.use_server_version()
+    with server.auth.sign_in(tableau_auth):
+        # Get workbook
+        all_workbooks, pagination_item = server.workbooks.get()
+        print("\nThere are {} workbooks on site: ".format(pagination_item.total_available))
+        print([workbook.name for workbook in all_workbooks])
+
+        if all_workbooks:
+            # Pick 1 workbook to try data acceleration.
+            # Note that data acceleration has a couple of requirements, please check the Tableau help page
+            # to verify your workbook/view is eligible for data acceleration.
+
+            # Assuming 1st workbook is eligible for sample purposes
+            sample_workbook = all_workbooks[2]
+
+            # Enable acceleration for all the views in the workbook
+            enable_config = dict()
+            enable_config["acceleration_enabled"] = True
+            enable_config["accelerate_now"] = True
+
+            sample_workbook.data_acceleration_config = enable_config
+            updated: TSC.WorkbookItem = server.workbooks.update(sample_workbook)
+            # Since we did not set any specific view, we will enable all views in the workbook
+            print("Enable acceleration for all the views in the workbook " + updated.name + ".")
+
+            # Disable acceleration on one of the view in the workbook
+            # You have to populate_views first, then set the views of the workbook
+            # to the ones you want to update.
+            server.workbooks.populate_views(sample_workbook)
+            view_to_disable = sample_workbook.views[0]
+            sample_workbook.views = [view_to_disable]
+
+            disable_config = dict()
+            disable_config["acceleration_enabled"] = False
+            disable_config["accelerate_now"] = True
+
+            sample_workbook.data_acceleration_config = disable_config
+            # To get the acceleration status on the response, set includeViewAccelerationStatus=true
+            # Note that you have to populate_views first to get the acceleration status, since
+            # acceleration status is per view basis (not per workbook)
+            updated: TSC.WorkbookItem = server.workbooks.update(sample_workbook, True)
+            view1 = updated.views[0]
+            print('Disabled acceleration for 1 view "' + view1.name + '" in the workbook ' + updated.name + ".")
+
+            # Get acceleration status of the views in workbook using workbooks.get_by_id
+            # This won't need to do populate_views beforehand
+            my_workbook = server.workbooks.get_by_id(sample_workbook.id)
+            view1 = my_workbook.views[0]
+            view2 = my_workbook.views[1]
+            print(
+                "Fetching acceleration status for views in the workbook "
+                + updated.name
+                + ".\n"
+                + 'View "'
+                + view1.name
+                + '" has acceleration_status = '
+                + view1.data_acceleration_config["acceleration_status"]
+                + ".\n"
+                + 'View "'
+                + view2.name
+                + '" has acceleration_status = '
+                + view2.data_acceleration_config["acceleration_status"]
+                + "."
+            )
+
+
+if __name__ == "__main__":
+    main()

tableauserverclient-0.30.post0.dev1/samples/update_workbook_data_freshness_policy.py

@@ -0,0 +1,218 @@
+####
+# This script demonstrates how to update workbook data freshness policy using the Tableau
+# Server Client.
+#
+# To run the script, you must have installed Python 3.7 or later.
+####
+
+
+import argparse
+import logging
+
+import tableauserverclient as TSC
+from tableauserverclient import IntervalItem
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Creates sample schedules for each type of frequency.")
+    # Common options; please keep those in sync across all samples
+    parser.add_argument("--server", "-s", help="server address")
+    parser.add_argument("--site", "-S", help="site name")
+    parser.add_argument("--token-name", "-p", help="name of the personal access token " "used to sign into the server")
+    parser.add_argument(
+        "--token-value", "-v", help="value of the personal access token " "used to sign into the server"
+    )
+    parser.add_argument(
+        "--logging-level",
+        "-l",
+        choices=["debug", "info", "error"],
+        default="error",
+        help="desired logging level (set to error by default)",
+    )
+    # Options specific to this sample:
+    # This sample has no additional options, yet. If you add some, please add them here
+
+    args = parser.parse_args()
+
+    # Set logging level based on user input, or error by default
+    logging_level = getattr(logging, args.logging_level.upper())
+    logging.basicConfig(level=logging_level)
+
+    tableau_auth = TSC.PersonalAccessTokenAuth(args.token_name, args.token_value, site_id=args.site)
+    server = TSC.Server(args.server, use_server_version=False)
+    server.add_http_options({"verify": False})
+    server.use_server_version()
+    with server.auth.sign_in(tableau_auth):
+        # Get workbook
+        all_workbooks, pagination_item = server.workbooks.get()
+        print("\nThere are {} workbooks on site: ".format(pagination_item.total_available))
+        print([workbook.name for workbook in all_workbooks])
+
+        if all_workbooks:
+            # Pick 1 workbook that has live datasource connection.
+            # Assuming 1st workbook met the criteria for sample purposes
+            # Data Freshness Policy is not available on extract & file-based datasource.
+            sample_workbook = all_workbooks[2]
+
+            # Get more info from the workbook selected
+            # Troubleshoot: if sample_workbook_extended.data_freshness_policy.option returns with AttributeError
+            # it could mean the workbook selected does not have live connection, which means it doesn't have
+            # data freshness policy. Change to another workbook with live datasource connection.
+            sample_workbook_extended = server.workbooks.get_by_id(sample_workbook.id)
+            try:
+                print(
+                    "Workbook "
+                    + sample_workbook.name
+                    + " has data freshness policy option set to: "
+                    + sample_workbook_extended.data_freshness_policy.option
+                )
+            except AttributeError as e:
+                print(
+                    "Workbook does not have data freshness policy, possibly due to the workbook selected "
+                    "does not have live connection. Change to another workbook using live datasource connection."
+                )
+
+            # Update Workbook Data Freshness Policy to "AlwaysLive"
+            sample_workbook.data_freshness_policy = TSC.DataFreshnessPolicyItem(
+                TSC.DataFreshnessPolicyItem.Option.AlwaysLive
+            )
+            updated: TSC.WorkbookItem = server.workbooks.update(sample_workbook)
+            print(
+                "Workbook "
+                + updated.name
+                + " updated data freshness policy option to: "
+                + updated.data_freshness_policy.option
+            )
+
+            # Update Workbook Data Freshness Policy to "SiteDefault"
+            sample_workbook.data_freshness_policy = TSC.DataFreshnessPolicyItem(
+                TSC.DataFreshnessPolicyItem.Option.SiteDefault
+            )
+            updated: TSC.WorkbookItem = server.workbooks.update(sample_workbook)
+            print(
+                "Workbook "
+                + updated.name
+                + " updated data freshness policy option to: "
+                + updated.data_freshness_policy.option
+            )
+
+            # Update Workbook Data Freshness Policy to "FreshEvery" schedule.
+            # Set the schedule to be fresh every 10 hours
+            # Once the data_freshness_policy is already populated (e.g. due to previous calls),
+            # it is possible to directly change the option & other parameters directly like below
+            sample_workbook.data_freshness_policy.option = TSC.DataFreshnessPolicyItem.Option.FreshEvery
+            fresh_every_ten_hours = TSC.DataFreshnessPolicyItem.FreshEvery(
+                TSC.DataFreshnessPolicyItem.FreshEvery.Frequency.Hours, 10
+            )
+            sample_workbook.data_freshness_policy.fresh_every_schedule = fresh_every_ten_hours
+            updated: TSC.WorkbookItem = server.workbooks.update(sample_workbook)
+            print(
+                "Workbook "
+                + updated.name
+                + " updated data freshness policy option to: "
+                + updated.data_freshness_policy.option
+                + " with frequency of "
+                + str(updated.data_freshness_policy.fresh_every_schedule.value)
+                + " "
+                + updated.data_freshness_policy.fresh_every_schedule.frequency
+            )
+
+            # Update Workbook Data Freshness Policy to "FreshAt" schedule.
+            # Set the schedule to be fresh at 10AM every day
+            sample_workbook.data_freshness_policy.option = TSC.DataFreshnessPolicyItem.Option.FreshAt
+            fresh_at_ten_daily = TSC.DataFreshnessPolicyItem.FreshAt(
+                TSC.DataFreshnessPolicyItem.FreshAt.Frequency.Day, "10:00:00", "America/Los_Angeles"
+            )
+            sample_workbook.data_freshness_policy.fresh_at_schedule = fresh_at_ten_daily
+            updated: TSC.WorkbookItem = server.workbooks.update(sample_workbook)
+            print(
+                "Workbook "
+                + updated.name
+                + " updated data freshness policy option to: "
+                + updated.data_freshness_policy.option
+                + " with frequency of "
+                + str(updated.data_freshness_policy.fresh_at_schedule.time)
+                + " every "
+                + updated.data_freshness_policy.fresh_at_schedule.frequency
+            )
+
+            # Set the schedule to be fresh at 6PM every week on Wednesday and Sunday
+            sample_workbook.data_freshness_policy = TSC.DataFreshnessPolicyItem(
+                TSC.DataFreshnessPolicyItem.Option.FreshAt
+            )
+            fresh_at_6pm_wed_sun = TSC.DataFreshnessPolicyItem.FreshAt(
+                TSC.DataFreshnessPolicyItem.FreshAt.Frequency.Week,
+                "18:00:00",
+                "America/Los_Angeles",
+                [IntervalItem.Day.Wednesday, "Sunday"],
+            )
+
+            sample_workbook.data_freshness_policy.fresh_at_schedule = fresh_at_6pm_wed_sun
+            updated: TSC.WorkbookItem = server.workbooks.update(sample_workbook)
+            new_fresh_at_schedule = updated.data_freshness_policy.fresh_at_schedule
+            print(
+                "Workbook "
+                + updated.name
+                + " updated data freshness policy option to: "
+                + updated.data_freshness_policy.option
+                + " with frequency of "
+                + str(new_fresh_at_schedule.time)
+                + " every "
+                + new_fresh_at_schedule.frequency
+                + " on "
+                + new_fresh_at_schedule.interval_item[0]
+                + ","
+                + new_fresh_at_schedule.interval_item[1]
+            )
+
+            # Set the schedule to be fresh at 12AM every last day of the month
+            sample_workbook.data_freshness_policy = TSC.DataFreshnessPolicyItem(
+                TSC.DataFreshnessPolicyItem.Option.FreshAt
+            )
+            fresh_at_last_day_of_month = TSC.DataFreshnessPolicyItem.FreshAt(
+                TSC.DataFreshnessPolicyItem.FreshAt.Frequency.Month, "00:00:00", "America/Los_Angeles", ["LastDay"]
+            )
+
+            sample_workbook.data_freshness_policy.fresh_at_schedule = fresh_at_last_day_of_month
+            updated: TSC.WorkbookItem = server.workbooks.update(sample_workbook)
+            new_fresh_at_schedule = updated.data_freshness_policy.fresh_at_schedule
+            print(
+                "Workbook "
+                + updated.name
+                + " updated data freshness policy option to: "
+                + updated.data_freshness_policy.option
+                + " with frequency of "
+                + str(new_fresh_at_schedule.time)
+                + " every "
+                + new_fresh_at_schedule.frequency
+                + " on "
+                + new_fresh_at_schedule.interval_item[0]
+            )
+
+            # Set the schedule to be fresh at 8PM every 1st,13th,20th day of the month
+            fresh_at_dates_of_month = TSC.DataFreshnessPolicyItem.FreshAt(
+                TSC.DataFreshnessPolicyItem.FreshAt.Frequency.Month,
+                "00:00:00",
+                "America/Los_Angeles",
+                ["1", "13", "20"],
+            )
+
+            sample_workbook.data_freshness_policy.fresh_at_schedule = fresh_at_dates_of_month
+            updated: TSC.WorkbookItem = server.workbooks.update(sample_workbook)
+            new_fresh_at_schedule = updated.data_freshness_policy.fresh_at_schedule
+            print(
+                "Workbook "
+                + updated.name
+                + " updated data freshness policy option to: "
+                + updated.data_freshness_policy.option
+                + " with frequency of "
+                + str(new_fresh_at_schedule.time)
+                + " every "
+                + new_fresh_at_schedule.frequency
+                + " on "
+                + str(new_fresh_at_schedule.interval_item)
+            )
+
+
+if __name__ == "__main__":
+    main()

{tableauserverclient-0.30 → tableauserverclient-0.30.post0.dev1}/tableauserverclient/__init__.py

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

{tableauserverclient-0.30 → tableauserverclient-0.30.post0.dev1}/tableauserverclient/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-01-19T11:30:24-0800",
+ "date": "2024-06-03T12:52:39-0700",
  "dirty": false,
  "error": null,
- "full-revisionid": "f84d7d5302344f0a4ac369c501b122931ae7e79e",
- "version": "0.30"
+ "full-revisionid": "4018a0ffc01bfa7c5b0024c6f112ced158d420b9",
+ "version": "0.30.post0.dev1"
 }
 '''  # END VERSION_JSON
 

{tableauserverclient-0.30 → tableauserverclient-0.30.post0.dev1}/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-0.30.post0.dev1/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-0.30 → tableauserverclient-0.30.post0.dev1}/tableauserverclient/models/interval_item.py

@@ -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-0.30 → tableauserverclient-0.30.post0.dev1}/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-0.30 → tableauserverclient-0.30.post0.dev1}/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-0.30 → tableauserverclient-0.30.post0.dev1}/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__(