Adding Schedules Support Round 2

samples/create_schedules.py

@@ -0,0 +1,78 @@
+####
+# This script demonstrates how to create schedules using the Tableau
+# Server Client.
+#
+# To run the script, you must have installed Python 2.7.9 or later.
+####
+
+
+import argparse
+import getpass
+import logging
+
+from datetime import time
+
+import tableauserverclient as TSC
+
+
+def main():
+
+    parser = argparse.ArgumentParser(description='Creates sample schedules for each type of frequency.')
+    parser.add_argument('--server', '-s', required=True, help='server address')
+    parser.add_argument('--username', '-u', required=True, help='username to sign into server')
+    parser.add_argument('--logging-level', '-l', choices=['debug', 'info', 'error'], default='error',
+                        help='desired logging level (set to error by default)')
+    args = parser.parse_args()
+
+    password = getpass.getpass("Password: ")
+
+    # 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.TableauAuth(args.username, password)
+    server = TSC.Server(args.server)
+    with server.auth.sign_in(tableau_auth):
+        # Hourly Schedule
+        # This schedule will run every 2 hours between 2:30AM and 11:00PM
+        hourly_interval = TSC.HourlyInterval(start_time=time(2, 30),
+                                             end_time=time(23, 0),
+                                             interval_occurrence=TSC.IntervalItem.Occurrence.Hours,
+                                             interval_value=2)
+
+        hourly_schedule = TSC.ScheduleItem("Hourly-Schedule", 50, TSC.ScheduleItem.Type.Extract,
+                                           TSC.ScheduleItem.ExecutionOrder.Parallel, hourly_interval)
+        hourly_schedule = server.schedules.create(hourly_schedule)
+        print("Hourly schedule created (ID: {}).".format(hourly_schedule.id))
+
+        # Daily Schedule
+        # This schedule will run every day at 5AM
+        daily_interval = TSC.DailyInterval(start_time=time(5))
+        daily_schedule = TSC.ScheduleItem("Daily-Schedule", 60, TSC.ScheduleItem.Type.Subscription,
+                                          TSC.ScheduleItem.ExecutionOrder.Serial, daily_interval)
+        daily_schedule = server.schedules.create(daily_schedule)
+        print("Daily schedule created (ID: {}).".format(daily_schedule.id))
+
+        # Weekly Schedule
+        # This schedule will wun every Monday, Wednesday, and Friday at 7:15PM
+        weekly_interval = TSC.WeeklyInterval(time(19, 15),
+                                             TSC.IntervalItem.Day.Monday,
+                                             TSC.IntervalItem.Day.Wednesday,
+                                             TSC.IntervalItem.Day.Friday)
+        weekly_schedule = TSC.ScheduleItem("Weekly-Schedule", 70, TSC.ScheduleItem.Type.Extract,
+                                           TSC.ScheduleItem.ExecutionOrder.Serial, weekly_interval)
+        weekly_schedule = server.schedules.create(weekly_schedule)
+        print("Weekly schedule created (ID: {}).".format(weekly_schedule.id))
+
+        # Monthly Schedule
+        # This schedule will run on the 15th of every month at 11:30PM
+        monthly_interval = TSC.MonthlyInterval(start_time=time(23, 30),
+                                               interval_value=15)
+        monthly_schedule = TSC.ScheduleItem("Monthly-Schedule", 80, TSC.ScheduleItem.Type.Subscription,
+                                            TSC.ScheduleItem.ExecutionOrder.Parallel, monthly_interval)
+        monthly_schedule = server.schedules.create(monthly_schedule)
+        print("Monthly schedule created (ID: {}).".format(monthly_schedule.id))
+
+
+if __name__ == '__main__':
+    main()

tableauserverclient/__init__.py

@@ -1,7 +1,8 @@
 from .namespace import NAMESPACE
 from .models import ConnectionItem, DatasourceItem,\
-    GroupItem, PaginationItem, ProjectItem, \
-    SiteItem, TableauAuth, UserItem, ViewItem, WorkbookItem, UnpopulatedPropertyError
+    GroupItem, PaginationItem, ProjectItem, ScheduleItem, \
+    SiteItem, TableauAuth, UserItem, ViewItem, WorkbookItem, UnpopulatedPropertyError, \
+    HourlyInterval, DailyInterval, WeeklyInterval, MonthlyInterval, IntervalItem
 from .server import RequestOptions, Filter, Sort, Server, ServerResponseError,\
     MissingRequiredFieldError, NotSignedInError
 

tableauserverclient/models/__init__.py

@@ -2,8 +2,10 @@
 from .datasource_item import DatasourceItem
 from .exceptions import UnpopulatedPropertyError
 from .group_item import GroupItem
+from .interval_item import IntervalItem, DailyInterval, WeeklyInterval, MonthlyInterval, HourlyInterval
 from .pagination_item import PaginationItem
 from .project_item import ProjectItem
+from .schedule_item import ScheduleItem
 from .site_item import SiteItem
 from .tableau_auth import TableauAuth
 from .user_item import UserItem

tableauserverclient/models/interval_item.py

@@ -0,0 +1,166 @@
+from .property_decorators import property_is_valid_time, property_not_nullable
+
+
+class IntervalItem(object):
+    class Frequency:
+        Hourly = "Hourly"
+        Daily = "Daily"
+        Weekly = "Weekly"
+        Monthly = "Monthly"
+
+    class Occurrence:
+        Minutes = "minutes"
+        Hours = "hours"
+        WeekDay = "weekDay"
+        MonthDay = "monthDay"
+
+    class Day:
+        Sunday = "Sunday"
+        Monday = "Monday"
+        Tuesday = "Tuesday"
+        Wednesday = "Wednesday"
+        Thursday = "Thursday"
+        Friday = "Friday"
+        Saturday = "Saturday"
+        LastDay = "LastDay"
+
+
+class HourlyInterval(object):
+    def __init__(self, start_time, end_time, interval_value):
+
+        self.start_time = start_time
+        self.end_time = end_time
+        self._frequency = IntervalItem.Frequency.Hourly
+        self.interval = interval_value
+
+    @property
+    def start_time(self):
+        return self._start_time
+
+    @start_time.setter
+    @property_is_valid_time
+    @property_not_nullable
+    def start_time(self, value):
+        self._start_time = value
+
+    @property
+    def end_time(self):
+        return self._end_time
+
+    @end_time.setter
+    @property_is_valid_time
+    @property_not_nullable
+    def end_time(self, value):
+        self._end_time = value
+
+    @property
+    def interval(self):
+        return self._interval
+
+    @interval.setter
+    def interval(self, interval):
+        VALID_INTERVALS = {.25, .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)
+
+        # We use fractional hours for the two minute-based intervals.
+        # Need to convert to minutes from hours here
+        if interval in {.25, .5}:
+            interval_value = int(interval * 60)
+            interval_occurrence = IntervalItem.Occurrence.Minutes
+        else:
+            interval_value = interval
+            interval_occurrence = IntervalItem.Occurrence.Hours
+
+        self._interval = [(interval_occurrence, str(interval_value))]
+
+
+class DailyInterval(object):
+    def __init__(self, start_time):
+        self.start_time = start_time
+        self._frequency = IntervalItem.Frequency.Daily
+        self.end_time = None
+        self.interval = None
+
+    @property
+    def start_time(self):
+        return self._start_time
+
+    @start_time.setter
+    @property_is_valid_time
+    @property_not_nullable
+    def start_time(self, value):
+        self._start_time = value
+
+
+class WeeklyInterval(object):
+    def __init__(self, start_time, *interval_values):
+        self.start_time = start_time
+        self._frequency = IntervalItem.Frequency.Weekly
+        self.interval = interval_values
+        self.end_time = None
+
+    @property
+    def start_time(self):
+        return self._start_time
+
+    @start_time.setter
+    @property_is_valid_time
+    @property_not_nullable
+    def start_time(self, value):
+        self._start_time = value
+
+    @property
+    def interval(self):
+        return self._interval
+
+    @interval.setter
+    def interval(self, interval_values):
+        if not all(hasattr(IntervalItem.Day, day) for day in interval_values):
+            raise ValueError("Invalid week day defined " + str(interval_values))
+
+        self._interval = [(IntervalItem.Occurrence.WeekDay, day) for day in interval_values]
+
+
+class MonthlyInterval(object):
+    def __init__(self, start_time, interval_value):
+        self.start_time = start_time
+        self._frequency = IntervalItem.Frequency.Monthly
+        self.interval = str(interval_value)
+        self.end_time = None
+
+    @property
+    def start_time(self):
+        return self._start_time
+
+    @start_time.setter
+    @property_is_valid_time
+    @property_not_nullable
+    def start_time(self, value):
+        self._start_time = value
+
+    @property
+    def interval(self):
+        return self._interval
+
+    @interval.setter
+    def interval(self, interval_value):
+        error = "Invalid interval value for a monthly frequency: {}.".format(interval_value)
+
+        # 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
+
+        if interval_value != "LastDay":
+            try:
+                if not (1 <= int(interval_value) <= 31):
+                    raise ValueError(error)
+            except ValueError as e:
+                if interval_value != "LastDay":
+                    raise ValueError(error)
+
+        self._interval = [(IntervalItem.Occurrence.MonthDay, str(interval_value))]

tableauserverclient/models/property_decorators.py

@@ -46,3 +46,34 @@ def wrapper(self, value):
         return func(self, value)
 
     return wrapper
+
+
+def property_is_valid_time(func):
+    @wraps(func)
+    def wrapper(self, value):
+        units_of_time = {"hour", "minute", "second"}
+
+        if not any(hasattr(value, unit) for unit in units_of_time):
+            error = "Invalid time object defined."
+            raise ValueError(error)
+        return func(self, value)
+
+    return wrapper
+
+
+def property_is_int(min, max=2**31):
+    def property_type_decorator(func):
+        @wraps(func)
+        def wrapper(self, value):
+            if min is None:
+                return func(self, value)
+
+            if value < min or value > max:
+                error = "Invalid priority defined: {}.".format(value)
+                raise ValueError(error)
+
+            return func(self, value)
+
+        return wrapper
+
+    return property_type_decorator