Merge pull request #5 from guodah/replace_mat_views_with_data_acceleration

replace materialized views with data acceleration

Author: guodah

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)

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"

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

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

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
 from .tag_item import TagItem
 from .view_item import ViewItem
 from .permissions_item import PermissionsRule

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 = {'accelerationEnabled': None, 'accelerateNow': 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
+            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

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:

tableauserverclient/server/request_factory.py

@@ -249,8 +249,6 @@ def update_req(self, project_item):
             project_element.attrib['description'] = project_item.description
         if project_item.content_permissions:
             project_element.attrib['contentPermissions'] = project_item.content_permissions
-        if project_item.parent_id is not None:
-            project_element.attrib['parentProjectId'] = project_item.parent_id
         return ET.tostring(xml_request)
 
     def create_req(self, project_item):
@@ -362,8 +360,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 +480,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)