diff --git a/samples/materialize_workbooks.py b/samples/materialize_workbooks.py deleted file mode 100644 index 696dda4b7..000000000 --- a/samples/materialize_workbooks.py +++ /dev/null @@ -1,342 +0,0 @@ -import argparse -import getpass -import logging -import os -import tableauserverclient as TSC -from collections import defaultdict - - -def main(): - parser = argparse.ArgumentParser(description='Materialized views settings for sites/workbooks.') - parser.add_argument('--server', '-s', required=True, help='Tableau server address') - parser.add_argument('--username', '-u', required=True, help='username to sign into server') - parser.add_argument('--password', '-p', required=False, help='password to sign into server') - parser.add_argument('--mode', '-m', required=False, choices=['disable', 'enable', 'enable_all', 'enable_selective'], - help='enable/disable materialized views for sites/workbooks') - parser.add_argument('--status', '-st', required=False, action='store_true', - help='show materialized views enabled sites/workbooks') - parser.add_argument('--site-id', '-si', required=False, - help='set to Default site by default') - parser.add_argument('--logging-level', '-l', choices=['debug', 'info', 'error'], default='error', - help='desired logging level (set to error by default)') - parser.add_argument('--type', '-t', required=False, choices=['site', 'workbook', 'project_name', 'project_path'], - help='type of content you want to update materialized views settings on') - parser.add_argument('--path-list', '-pl', required=False, help='path to a list of workbook paths') - parser.add_argument('--name-list', '-nl', required=False, help='path to a list of workbook names') - parser.add_argument('--project-name', '-pn', required=False, help='name of the project') - parser.add_argument('--project-path', '-pp', required=False, help="path of the project") - parser.add_argument('--materialize-now', '-mn', required=False, action='store_true', - help='create materialized views for workbooks immediately') - - args = parser.parse_args() - - if args.password: - password = args.password - else: - password = getpass.getpass("Password: ") - - logging_level = getattr(logging, args.logging_level.upper()) - logging.basicConfig(level=logging_level) - - # site content url is the TSC term for site id - site_content_url = args.site_id if args.site_id is not None else "" - - if not assert_options_valid(args): - return - - materialized_views_config = create_materialized_views_config(args) - - # enable/disable materialized views for site - if args.type == 'site': - if not update_site(args, password, site_content_url): - return - - # enable/disable materialized views for workbook - # works only when the site the workbooks belong to are enabled too - elif args.type == 'workbook': - if not update_workbook(args, materialized_views_config, password, site_content_url): - return - - # enable/disable materialized views for project by project name - # will show possible projects when project name is not unique - elif args.type == 'project_name': - if not update_project_by_name(args, materialized_views_config, password, site_content_url): - return - - # enable/disable materialized views for project by project path, for example: project1/project2 - elif args.type == 'project_path': - if not update_project_by_path(args, materialized_views_config, password, site_content_url): - return - - # show enabled sites and workbooks - if args.status: - show_materialized_views_status(args, password, site_content_url) - - -def find_project_path(project, all_projects, path): - # project stores the id of it's parent - # this method is to run recursively to find the path from root project to given project - path = project.name if len(path) == 0 else project.name + '/' + path - - if project.parent_id is None: - return path - else: - return find_project_path(all_projects[project.parent_id], all_projects, path) - - -def get_project_paths(server, projects): - # most likely user won't have too many projects so we store them in a dict to search - all_projects = {project.id: project for project in TSC.Pager(server.projects)} - - result = dict() - for project in projects: - result[find_project_path(project, all_projects, "")] = project - return result - - -def print_paths(paths): - for path in paths.keys(): - print(path) - - -def show_materialized_views_status(args, password, site_content_url): - tableau_auth = TSC.TableauAuth(args.username, password, site_id=site_content_url) - server = TSC.Server(args.server, use_server_version=True) - enabled_sites = set() - with server.auth.sign_in(tableau_auth): - # For server admin, this will prints all the materialized views enabled sites - # For other users, this only prints the status of the site they belong to - print("Materialized views is enabled on sites:") - # only server admins can get all the sites in the server - # other users can only get the site they are in - for site in TSC.Pager(server.sites): - if site.materialized_views_mode != "disable": - enabled_sites.add(site) - print("Site name: {}".format(site.name)) - print('\n') - - print("Materialized views is enabled on workbooks:") - # Individual workbooks can be enabled only when the sites they belong to are enabled too - for site in enabled_sites: - site_auth = TSC.TableauAuth(args.username, password, site.content_url) - with server.auth.sign_in(site_auth): - for workbook in TSC.Pager(server.workbooks): - if workbook.materialized_views_config['materialized_views_enabled']: - print("Workbook: {} from site: {}".format(workbook.name, site.name)) - - -def update_project_by_path(args, materialized_views_config, password, site_content_url): - if args.project_path is None: - print("Use --project_path to specify the path of the project") - return False - tableau_auth = TSC.TableauAuth(args.username, password, site_content_url) - server = TSC.Server(args.server, use_server_version=True) - project_name = args.project_path.split('/')[-1] - with server.auth.sign_in(tableau_auth): - if not assert_site_enabled_for_materialized_views(server, site_content_url): - return False - projects = [project for project in TSC.Pager(server.projects) if project.name == project_name] - if not assert_project_valid(args.project_path, projects): - return False - - possible_paths = get_project_paths(server, projects) - update_project(possible_paths[args.project_path], server, materialized_views_config) - return True - - -def update_project_by_name(args, materialized_views_config, password, site_content_url): - if args.project_name is None: - print("Use --project-name to specify the name of the project") - return False - tableau_auth = TSC.TableauAuth(args.username, password, site_content_url) - server = TSC.Server(args.server, use_server_version=True) - with server.auth.sign_in(tableau_auth): - if not assert_site_enabled_for_materialized_views(server, site_content_url): - return False - # get all projects with given name - projects = [project for project in TSC.Pager(server.projects) if project.name == args.project_name] - if not assert_project_valid(args.project_name, projects): - return False - - if len(projects) > 1: - possible_paths = get_project_paths(server, projects) - print("Project name is not unique, use '--project_path '") - print("Possible project paths:") - print_paths(possible_paths) - print('\n') - return False - else: - update_project(projects[0], server, materialized_views_config) - return True - - -def update_project(project, server, materialized_views_config): - all_projects = list(TSC.Pager(server.projects)) - project_ids = find_project_ids_to_update(all_projects, project) - for workbook in TSC.Pager(server.workbooks): - if workbook.project_id in project_ids: - workbook.materialized_views_config = materialized_views_config - server.workbooks.update(workbook) - - print("Updated materialized views settings for project: {}".format(project.name)) - print('\n') - - -def find_project_ids_to_update(all_projects, project): - projects_to_update = [] - find_projects_to_update(project, all_projects, projects_to_update) - return set([project_to_update.id for project_to_update in projects_to_update]) - - -def parse_workbook_path(file_path): - # parse the list of project path of workbooks - workbook_paths = sanitize_workbook_list(file_path, "path") - - workbook_path_mapping = defaultdict(list) - for workbook_path in workbook_paths: - workbook_project = workbook_path.rstrip().split('/') - workbook_path_mapping[workbook_project[-1]].append('/'.join(workbook_project[:-1])) - return workbook_path_mapping - - -def update_workbook(args, materialized_views_config, password, site_content_url): - if args.path_list is None and args.name_list is None: - print("Use '--path-list ' or '--name-list ' to specify the path of a list of workbooks") - print('\n') - return False - tableau_auth = TSC.TableauAuth(args.username, password, site_id=site_content_url) - server = TSC.Server(args.server, use_server_version=True) - with server.auth.sign_in(tableau_auth): - if not assert_site_enabled_for_materialized_views(server, site_content_url): - return False - if args.path_list is not None: - workbook_path_mapping = parse_workbook_path(args.path_list) - all_projects = {project.id: project for project in TSC.Pager(server.projects)} - update_workbooks_by_paths(all_projects, materialized_views_config, server, workbook_path_mapping) - elif args.name_list is not None: - update_workbooks_by_names(args.name_list, server, materialized_views_config) - return True - - -def update_workbooks_by_paths(all_projects, materialized_views_config, server, workbook_path_mapping): - for workbook_name, workbook_paths in workbook_path_mapping.items(): - req_option = TSC.RequestOptions() - req_option.filter.add(TSC.Filter(TSC.RequestOptions.Field.Name, - TSC.RequestOptions.Operator.Equals, - workbook_name)) - workbooks = list(TSC.Pager(server.workbooks, req_option)) - all_paths = set(workbook_paths[:]) - for workbook in workbooks: - path = find_project_path(all_projects[workbook.project_id], all_projects, "") - if path in workbook_paths: - all_paths.remove(path) - workbook.materialized_views_config = materialized_views_config - server.workbooks.update(workbook) - print("Updated materialized views settings for workbook: {}".format(path + '/' + workbook.name)) - - for path in all_paths: - print("Cannot find workbook path: {}, each line should only contain one workbook path" - .format(path + '/' + workbook_name)) - print('\n') - - -def update_workbooks_by_names(name_list, server, materialized_views_config): - workbook_names = sanitize_workbook_list(name_list, "name") - for workbook_name in workbook_names: - req_option = TSC.RequestOptions() - req_option.filter.add(TSC.Filter(TSC.RequestOptions.Field.Name, - TSC.RequestOptions.Operator.Equals, - workbook_name.rstrip())) - workbooks = list(TSC.Pager(server.workbooks, req_option)) - if len(workbooks) == 0: - print("Cannot find workbook name: {}, each line should only contain one workbook name" - .format(workbook_name)) - for workbook in workbooks: - workbook.materialized_views_config = materialized_views_config - server.workbooks.update(workbook) - print("Updated materialized views settings for workbook: {}".format(workbook.name)) - print('\n') - - -def update_site(args, password, site_content_url): - if not assert_site_options_valid(args): - return False - tableau_auth = TSC.TableauAuth(args.username, password, site_id=site_content_url) - server = TSC.Server(args.server, use_server_version=True) - with server.auth.sign_in(tableau_auth): - site_to_update = server.sites.get_by_content_url(site_content_url) - site_to_update.materialized_views_mode = args.mode - - server.sites.update(site_to_update) - print("Updated materialized views settings for site: {}".format(site_to_update.name)) - print('\n') - return True - - -def create_materialized_views_config(args): - materialized_views_config = dict() - materialized_views_config['materialized_views_enabled'] = args.mode == "enable" - materialized_views_config['run_materialization_now'] = True if args.materialize_now else False - return materialized_views_config - - -def assert_site_options_valid(args): - if args.materialize_now: - print('"--materialize-now" only applies to workbook/project type') - return False - if args.mode == 'enable': - print('For site type please choose from "disable", "enable_all", or "enable_selective"') - return False - return True - - -def assert_options_valid(args): - if args.type != "site" and args.mode in ("enable_all", "enable_selective"): - print('"enable_all" and "enable_selective" do not apply to workbook/project type') - return False - if (args.type is None) != (args.mode is None): - print("Use '--type --mode ' to update materialized views settings.") - return False - return True - - -def assert_site_enabled_for_materialized_views(server, site_content_url): - parent_site = server.sites.get_by_content_url(site_content_url) - if parent_site.materialized_views_mode == "disable": - print('Cannot update workbook/project because site is disabled for materialized views') - return False - return True - - -def assert_project_valid(project_name, projects): - if len(projects) == 0: - print("Cannot find project: {}".format(project_name)) - return False - return True - - -def find_projects_to_update(project, all_projects, projects_to_update): - # Use recursion to find all the sub-projects and enable/disable the workbooks in them - projects_to_update.append(project) - children_projects = [child for child in all_projects if child.parent_id == project.id] - if len(children_projects) == 0: - return - - for child in children_projects: - find_projects_to_update(child, all_projects, projects_to_update) - - -def sanitize_workbook_list(file_name, file_type): - if not os.path.isfile(file_name): - print("Invalid file name '{}'".format(file_name)) - return [] - file_list = open(file_name, "r") - - if file_type == "name": - return [workbook.rstrip() for workbook in file_list if not workbook.isspace()] - if file_type == "path": - return [workbook.rstrip() for workbook in file_list if not workbook.isspace()] - - -if __name__ == "__main__": - main() diff --git a/tableauserverclient/models/property_decorators.py b/tableauserverclient/models/property_decorators.py index a4ef0ef3f..d893305f7 100644 --- a/tableauserverclient/models/property_decorators.py +++ b/tableauserverclient/models/property_decorators.py @@ -138,16 +138,16 @@ def wrapper(self, value): return wrapper -def property_is_materialized_views_config(func): +def property_is_data_acceleration_config(func): @wraps(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) != 2 or not all(attr in value.keys() for attr in ('materialized_views_enabled', - 'run_materialization_now')): + 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 += "'materialized_views_enabled' and 'run_materialization_now'" + error += "'acceleration_enabled' and 'accelerate_now'" error += "instead you have {}".format(value.keys()) raise ValueError(error) return func(self, value) diff --git a/tableauserverclient/models/schedule_item.py b/tableauserverclient/models/schedule_item.py index 5ece2f8fe..c93ffe922 100644 --- a/tableauserverclient/models/schedule_item.py +++ b/tableauserverclient/models/schedule_item.py @@ -11,7 +11,7 @@ class Type: Extract = "Extract" Flow = "Flow" Subscription = "Subscription" - MaterializeViews = "MaterializeViews" + DataAcceleration = "DataAcceleration" class ExecutionOrder: Parallel = "Parallel" diff --git a/tableauserverclient/models/site_item.py b/tableauserverclient/models/site_item.py index 238332597..1ba854e72 100644 --- a/tableauserverclient/models/site_item.py +++ b/tableauserverclient/models/site_item.py @@ -17,7 +17,7 @@ class State: def __init__(self, name, content_url, admin_mode=None, user_quota=None, storage_quota=None, disable_subscriptions=False, subscribe_others_enabled=True, revision_history_enabled=False, - revision_limit=None, materialized_views_mode=None, flows_enabled=None, cataloging_enabled=None): + revision_limit=None, data_acceleration_mode=None, flows_enabled=None, cataloging_enabled=None): self._admin_mode = None self._id = None self._num_users = None @@ -33,7 +33,7 @@ def __init__(self, name, content_url, admin_mode=None, user_quota=None, storage_ self.revision_history_enabled = revision_history_enabled self.subscribe_others_enabled = subscribe_others_enabled self.admin_mode = admin_mode - self.materialized_views_mode = materialized_views_mode + self.data_acceleration_mode = data_acceleration_mode self.cataloging_enabled = cataloging_enabled self.flows_enabled = flows_enabled @@ -127,12 +127,12 @@ def subscribe_others_enabled(self, value): self._subscribe_others_enabled = value @property - def materialized_views_mode(self): - return self._materialized_views_mode + def data_acceleration_mode(self): + return self._data_acceleration_mode - @materialized_views_mode.setter - def materialized_views_mode(self, value): - self._materialized_views_mode = value + @data_acceleration_mode.setter + def data_acceleration_mode(self, value): + self._data_acceleration_mode = value @property def cataloging_enabled(self): @@ -160,17 +160,17 @@ def _parse_common_tags(self, site_xml, ns): (_, name, content_url, _, admin_mode, state, subscribe_others_enabled, disable_subscriptions, revision_history_enabled, user_quota, storage_quota, revision_limit, num_users, storage, - materialized_views_mode, cataloging_enabled, flows_enabled) = self._parse_element(site_xml, ns) + data_acceleration_mode, cataloging_enabled, flows_enabled) = self._parse_element(site_xml, ns) self._set_values(None, name, content_url, None, admin_mode, state, subscribe_others_enabled, disable_subscriptions, revision_history_enabled, user_quota, storage_quota, - revision_limit, num_users, storage, materialized_views_mode, cataloging_enabled, + revision_limit, num_users, storage, data_acceleration_mode, cataloging_enabled, flows_enabled) return self def _set_values(self, id, name, content_url, status_reason, admin_mode, state, subscribe_others_enabled, disable_subscriptions, revision_history_enabled, - user_quota, storage_quota, revision_limit, num_users, storage, materialized_views_mode, + user_quota, storage_quota, revision_limit, num_users, storage, data_acceleration_mode, flows_enabled, cataloging_enabled): if id is not None: self._id = id @@ -200,8 +200,8 @@ def _set_values(self, id, name, content_url, status_reason, admin_mode, state, self._num_users = num_users if storage: self._storage = storage - if materialized_views_mode: - self._materialized_views_mode = materialized_views_mode + if data_acceleration_mode: + self._data_acceleration_mode = data_acceleration_mode if flows_enabled is not None: self.flows_enabled = flows_enabled if cataloging_enabled is not None: @@ -215,14 +215,14 @@ def from_response(cls, resp, ns): for site_xml in all_site_xml: (id, name, content_url, status_reason, admin_mode, state, subscribe_others_enabled, disable_subscriptions, revision_history_enabled, user_quota, storage_quota, - revision_limit, num_users, storage, materialized_views_mode, flows_enabled, + revision_limit, num_users, storage, data_acceleration_mode, flows_enabled, cataloging_enabled) = cls._parse_element(site_xml, ns) site_item = cls(name, content_url) site_item._set_values(id, name, content_url, status_reason, admin_mode, state, subscribe_others_enabled, disable_subscriptions, revision_history_enabled, user_quota, storage_quota, revision_limit, num_users, storage, - materialized_views_mode, flows_enabled, cataloging_enabled) + data_acceleration_mode, flows_enabled, cataloging_enabled) all_site_items.append(site_item) return all_site_items @@ -257,14 +257,14 @@ def _parse_element(site_xml, ns): num_users = usage_elem.get('numUsers', None) storage = usage_elem.get('storage', None) - materialized_views_mode = site_xml.get('materializedViewsMode', '') + data_acceleration_mode = site_xml.get('dataAccelerationMode', '') flows_enabled = string_to_bool(site_xml.get('flowsEnabled', '')) cataloging_enabled = string_to_bool(site_xml.get('catalogingEnabled', '')) return id, name, content_url, status_reason, admin_mode, state, subscribe_others_enabled,\ disable_subscriptions, revision_history_enabled, user_quota, storage_quota,\ - revision_limit, num_users, storage, materialized_views_mode, flows_enabled, cataloging_enabled + revision_limit, num_users, storage, data_acceleration_mode, flows_enabled, cataloging_enabled # Used to convert string represented boolean to a boolean type diff --git a/tableauserverclient/models/task_item.py b/tableauserverclient/models/task_item.py index 2b08eee05..780412af9 100644 --- a/tableauserverclient/models/task_item.py +++ b/tableauserverclient/models/task_item.py @@ -7,7 +7,7 @@ class TaskItem(object): class Type: ExtractRefresh = "extractRefresh" - MaterializeViews = "materializeViews" + DataAcceleration = "dataAcceleration" def __init__(self, id_, task_type, priority, consecutive_failed_count=0, schedule_id=None, schedule_item=None, last_run_at=None, target=None): diff --git a/tableauserverclient/models/webhook_item.py b/tableauserverclient/models/webhook_item.py index 4b1a350ee..90fdd4ba2 100644 --- a/tableauserverclient/models/webhook_item.py +++ b/tableauserverclient/models/webhook_item.py @@ -1,6 +1,6 @@ import xml.etree.ElementTree as ET from .exceptions import UnpopulatedPropertyError -from .property_decorators import property_not_nullable, property_is_boolean, property_is_materialized_views_config +from .property_decorators import property_not_nullable, property_is_boolean, property_is_data_acceleration_config from .tag_item import TagItem from .view_item import ViewItem from .permissions_item import PermissionsRule diff --git a/tableauserverclient/models/workbook_item.py b/tableauserverclient/models/workbook_item.py index ce4f43ed5..75acb5b15 100644 --- a/tableauserverclient/models/workbook_item.py +++ b/tableauserverclient/models/workbook_item.py @@ -1,6 +1,6 @@ import xml.etree.ElementTree as ET from .exceptions import UnpopulatedPropertyError -from .property_decorators import property_not_nullable, property_is_boolean, property_is_materialized_views_config +from .property_decorators import property_not_nullable, property_is_boolean, property_is_data_acceleration_config from .tag_item import TagItem from .view_item import ViewItem from .permissions_item import PermissionsRule @@ -27,8 +27,8 @@ def __init__(self, project_id, name=None, show_tabs=False): self.project_id = project_id self.show_tabs = show_tabs self.tags = set() - self.materialized_views_config = {'materialized_views_enabled': None, - 'run_materialization_now': None} + self.data_acceleration_config = {'acceleration_enabled': None, + 'accelerate_now': None} self._permissions = None @property @@ -123,13 +123,13 @@ def views(self): return self._views @property - def materialized_views_config(self): - return self._materialized_views_config + def data_acceleration_config(self): + return self._data_acceleration_config - @materialized_views_config.setter - @property_is_materialized_views_config - def materialized_views_config(self, value): - self._materialized_views_config = value + @data_acceleration_config.setter + @property_is_data_acceleration_config + def data_acceleration_config(self, value): + self._data_acceleration_config = value def _set_connections(self, connections): self._connections = connections @@ -152,17 +152,17 @@ def _parse_common_tags(self, workbook_xml, ns): if workbook_xml is not None: (_, _, _, _, description, updated_at, _, show_tabs, project_id, project_name, owner_id, _, _, - materialized_views_config) = self._parse_element(workbook_xml, ns) + data_acceleration_config) = self._parse_element(workbook_xml, ns) self._set_values(None, None, None, None, description, updated_at, None, show_tabs, project_id, project_name, owner_id, None, None, - materialized_views_config) + data_acceleration_config) return self def _set_values(self, id, name, content_url, created_at, description, updated_at, size, show_tabs, project_id, project_name, owner_id, tags, views, - materialized_views_config): + data_acceleration_config): if id is not None: self._id = id if name: @@ -190,8 +190,8 @@ def _set_values(self, id, name, content_url, created_at, description, updated_at self._initial_tags = copy.copy(tags) if views: self._views = views - if materialized_views_config is not None: - self.materialized_views_config = materialized_views_config + if data_acceleration_config is not None: + self.data_acceleration_config = data_acceleration_config @classmethod def from_response(cls, resp, ns): @@ -201,12 +201,12 @@ def from_response(cls, resp, ns): for workbook_xml in all_workbook_xml: (id, name, content_url, created_at, description, updated_at, size, show_tabs, project_id, project_name, owner_id, tags, views, - materialized_views_config) = cls._parse_element(workbook_xml, ns) + data_acceleration_config) = cls._parse_element(workbook_xml, ns) workbook_item = cls(project_id) workbook_item._set_values(id, name, content_url, created_at, description, updated_at, size, show_tabs, None, project_name, owner_id, tags, views, - materialized_views_config) + data_acceleration_config) all_workbook_items.append(workbook_item) return all_workbook_items @@ -248,29 +248,29 @@ def _parse_element(workbook_xml, ns): if views_elem is not None: views = ViewItem.from_xml_element(views_elem, ns) - materialized_views_config = {'materialized_views_enabled': None, 'run_materialization_now': None} - materialized_views_elem = workbook_xml.find('.//t:materializedViewsEnablementConfig', namespaces=ns) - if materialized_views_elem is not None: - materialized_views_config = parse_materialized_views_config(materialized_views_elem) + data_acceleration_config = {'acceleration_enabled': None, 'accelerate_now': None} + data_acceleration_elem = workbook_xml.find('.//t:dataAccelerationConfig', namespaces=ns) + if data_acceleration_elem is not None: + data_acceleration_config = parse_data_acceleration_config(data_acceleration_elem) - return id, name, content_url, created_at, description, updated_at, size, show_tabs,\ - project_id, project_name, owner_id, tags, views, materialized_views_config + return id, name, content_url, created_at, description, updated_at, size, show_tabs, \ + project_id, project_name, owner_id, tags, views, data_acceleration_config -def parse_materialized_views_config(materialized_views_elem): - materialized_views_config = dict() +def parse_data_acceleration_config(data_acceleration_elem): + data_acceleration_config = dict() - materialized_views_enabled = materialized_views_elem.get('materializedViewsEnabled', None) - if materialized_views_enabled is not None: - materialized_views_enabled = string_to_bool(materialized_views_enabled) + acceleration_enabled = data_acceleration_elem.get('accelerationEnabled', None) + if acceleration_enabled is not None: + acceleration_enabled = string_to_bool(acceleration_enabled) - run_materialization_now = materialized_views_elem.get('runMaterializationNow', None) - if run_materialization_now is not None: - run_materialization_now = string_to_bool(run_materialization_now) + accelerate_now = data_acceleration_elem.get('accelerateNow', None) + if accelerate_now is not None: + accelerate_now = string_to_bool(accelerate_now) - materialized_views_config['materialized_views_enabled'] = materialized_views_enabled - materialized_views_config['run_materialization_now'] = run_materialization_now - return materialized_views_config + data_acceleration_config['acceleration_enabled'] = acceleration_enabled + data_acceleration_config['accelerate_now'] = accelerate_now + return data_acceleration_config # Used to convert string represented boolean to a boolean type diff --git a/tableauserverclient/server/endpoint/tasks_endpoint.py b/tableauserverclient/server/endpoint/tasks_endpoint.py index 2abe87104..d08209769 100644 --- a/tableauserverclient/server/endpoint/tasks_endpoint.py +++ b/tableauserverclient/server/endpoint/tasks_endpoint.py @@ -24,7 +24,7 @@ def __normalize_task_type(self, task_type): @api(version='2.6') def get(self, req_options=None, task_type=TaskItem.Type.ExtractRefresh): - if task_type == TaskItem.Type.MaterializeViews: + if task_type == TaskItem.Type.DataAcceleration: self.parent_srv.assert_at_least_version("3.8") logger.info('Querying all {} tasks for the site'.format(task_type)) @@ -65,7 +65,7 @@ def run(self, task_item): # Delete 1 task by id @api(version="3.6") def delete(self, task_id, task_type=TaskItem.Type.ExtractRefresh): - if task_type == TaskItem.Type.MaterializeViews: + if task_type == TaskItem.Type.DataAcceleration: self.parent_srv.assert_at_least_version("3.8") if not task_id: diff --git a/tableauserverclient/server/request_factory.py b/tableauserverclient/server/request_factory.py index b447b072b..87529b84f 100644 --- a/tableauserverclient/server/request_factory.py +++ b/tableauserverclient/server/request_factory.py @@ -362,8 +362,8 @@ def update_req(self, site_item): site_element.attrib['revisionLimit'] = str(site_item.revision_limit) if site_item.subscribe_others_enabled: site_element.attrib['revisionHistoryEnabled'] = str(site_item.revision_history_enabled).lower() - if site_item.materialized_views_mode is not None: - site_element.attrib['materializedViewsMode'] = str(site_item.materialized_views_mode).lower() + if site_item.data_acceleration_mode is not None: + site_element.attrib['dataAccelerationMode'] = str(site_item.data_acceleration_mode).lower() if site_item.flows_enabled is not None: site_element.attrib['flowsEnabled'] = str(site_item.flows_enabled).lower() if site_item.cataloging_enabled is not None: @@ -482,15 +482,15 @@ def update_req(self, workbook_item): if workbook_item.owner_id: owner_element = ET.SubElement(workbook_element, 'owner') owner_element.attrib['id'] = workbook_item.owner_id - if workbook_item.materialized_views_config is not None and \ - 'materialized_views_enabled' in workbook_item.materialized_views_config: - materialized_views_config = workbook_item.materialized_views_config - materialized_views_element = ET.SubElement(workbook_element, 'materializedViewsEnablementConfig') - materialized_views_element.attrib['materializedViewsEnabled'] = str(materialized_views_config - ["materialized_views_enabled"]).lower() - if "run_materialization_now" in materialized_views_config: - materialized_views_element.attrib['materializeNow'] = str(materialized_views_config - ["run_materialization_now"]).lower() + if workbook_item.data_acceleration_config is not None and \ + 'acceleration_enabled' in 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 "accelerate_now" in data_acceleration_config: + data_acceleration_element.attrib['accelerateNow'] = str(data_acceleration_config + ["accelerate_now"]).lower() return ET.tostring(xml_request) diff --git a/test/assets/schedule_add_workbook_with_warnings.xml b/test/assets/schedule_add_workbook_with_warnings.xml index 0c376d018..1eac2ceef 100644 --- a/test/assets/schedule_add_workbook_with_warnings.xml +++ b/test/assets/schedule_add_workbook_with_warnings.xml @@ -1,9 +1,9 @@ - + - + diff --git a/test/assets/tasks_with_materializeviews_task.xml b/test/assets/tasks_with_dataacceleration_task.xml similarity index 79% rename from test/assets/tasks_with_materializeviews_task.xml rename to test/assets/tasks_with_dataacceleration_task.xml index e586b6bb1..cbe837405 100644 --- a/test/assets/tasks_with_materializeviews_task.xml +++ b/test/assets/tasks_with_dataacceleration_task.xml @@ -2,8 +2,8 @@ - - + + @@ -12,7 +12,7 @@ 2019-12-09T20:45:04Z - + \ No newline at end of file diff --git a/test/test_site.py b/test/test_site.py index 8283a7bdd..09063b861 100644 --- a/test/test_site.py +++ b/test/test_site.py @@ -92,7 +92,7 @@ def test_update(self): admin_mode=TSC.SiteItem.AdminMode.ContentAndUsers, user_quota=15, storage_quota=1000, disable_subscriptions=True, revision_history_enabled=False, - materialized_views_mode='disable') + data_acceleration_mode='disable') single_site._id = '6b7179ba-b82b-4f0f-91ed-812074ac5da6' single_site = self.server.sites.update(single_site) @@ -105,7 +105,7 @@ def test_update(self): self.assertEqual(13, single_site.revision_limit) self.assertEqual(True, single_site.disable_subscriptions) self.assertEqual(15, single_site.user_quota) - self.assertEqual('disable', single_site.materialized_views_mode) + self.assertEqual('disable', single_site.data_acceleration_mode) self.assertEqual(True, single_site.flows_enabled) self.assertEqual(True, single_site.cataloging_enabled) diff --git a/test/test_task.py b/test/test_task.py index a0699bc49..cf7879305 100644 --- a/test/test_task.py +++ b/test/test_task.py @@ -11,7 +11,7 @@ GET_XML_WITH_WORKBOOK = os.path.join(TEST_ASSET_DIR, "tasks_with_workbook.xml") GET_XML_WITH_DATASOURCE = os.path.join(TEST_ASSET_DIR, "tasks_with_datasource.xml") GET_XML_WITH_WORKBOOK_AND_DATASOURCE = os.path.join(TEST_ASSET_DIR, "tasks_with_workbook_and_datasource.xml") -GET_XML_MATERIALIZEVIEWS_TASK = os.path.join(TEST_ASSET_DIR, "tasks_with_materializeviews_task.xml") +GET_XML_DATAACCELERATION_TASK = os.path.join(TEST_ASSET_DIR, "tasks_with_dataacceleration_task.xml") GET_XML_RUN_NOW_RESPONSE = os.path.join(TEST_ASSET_DIR, "tasks_run_now_response.xml") @@ -91,12 +91,12 @@ def test_delete_missing_id(self): self.assertRaises(ValueError, self.server.tasks.delete, '') def test_get_materializeviews_tasks(self): - with open(GET_XML_MATERIALIZEVIEWS_TASK, "rb") as f: + with open(GET_XML_DATAACCELERATION_TASK, "rb") as f: response_xml = f.read().decode("utf-8") with requests_mock.mock() as m: m.get('{}/{}'.format( - self.server.tasks.baseurl, TaskItem.Type.MaterializeViews), text=response_xml) - all_tasks, pagination_item = self.server.tasks.get(task_type=TaskItem.Type.MaterializeViews) + self.server.tasks.baseurl, TaskItem.Type.DataAcceleration), text=response_xml) + all_tasks, pagination_item = self.server.tasks.get(task_type=TaskItem.Type.DataAcceleration) task = all_tasks[0] self.assertEqual('a462c148-fc40-4670-a8e4-39b7f0c58c7f', task.target.id) @@ -108,10 +108,10 @@ def test_get_materializeviews_tasks(self): def test_delete(self): with requests_mock.mock() as m: m.delete('{}/{}/{}'.format( - self.server.tasks.baseurl, TaskItem.Type.MaterializeViews, + self.server.tasks.baseurl, TaskItem.Type.DataAcceleration, 'c9cff7f9-309c-4361-99ff-d4ba8c9f5467'), status_code=204) self.server.tasks.delete('c9cff7f9-309c-4361-99ff-d4ba8c9f5467', - TaskItem.Type.MaterializeViews) + TaskItem.Type.DataAcceleration) def test_get_by_id(self): with open(GET_XML_WITH_WORKBOOK, "rb") as f: