194 fix namespace issue (#219)

* Moving user endpoint to use dynamic namespace

* move groups to using dynamic namespace

* move PagintationItem to use dynamic namespace

* move exceptions to use dynamic namespace

* move workbooks to use dynamic namespace

* move views to use dynamic namespace

* move views to use dynamic namespace

* move tasks to use dynamic namespace

* move tags to use dynamic namespace

* move datasource to use dynamic namespace

* move connections item to use dynamic namespace

* move site to use dynamic namespace

* fix up tests and remove NAMESPACE

* move namespace to be a property

* Move detection into a Namespace class

* Move to using the Namespace class

* remove deprecated namespace code

* better detection method from Tyler's suggestion

* fixing pycodestyle failures

* removing unneeded import

* throwing an exception if there is a unknown namespace

Author: Russell Hay

tableauserverclient/__init__.py

@@ -1,4 +1,4 @@
-from .namespace import NAMESPACE
+from .namespace import NEW_NAMESPACE as DEFAULT_NAMESPACE
 from .models import ConnectionCredentials, ConnectionItem, DatasourceItem,\
     GroupItem, PaginationItem, ProjectItem, ScheduleItem, \
     SiteItem, TableauAuth, UserItem, ViewItem, WorkbookItem, UnpopulatedPropertyError, \

tableauserverclient/models/connection_item.py

@@ -1,5 +1,4 @@
 import xml.etree.ElementTree as ET
-from .. import NAMESPACE
 
 
 class ConnectionItem(object):
@@ -31,18 +30,18 @@ def connection_type(self):
         return self._connection_type
 
     @classmethod
-    def from_response(cls, resp):
+    def from_response(cls, resp, ns):
         all_connection_items = list()
         parsed_response = ET.fromstring(resp)
-        all_connection_xml = parsed_response.findall('.//t:connection', namespaces=NAMESPACE)
+        all_connection_xml = parsed_response.findall('.//t:connection', namespaces=ns)
         for connection_xml in all_connection_xml:
             connection_item = cls()
             connection_item._id = connection_xml.get('id', None)
             connection_item._connection_type = connection_xml.get('type', None)
             connection_item.server_address = connection_xml.get('serverAddress', None)
             connection_item.server_port = connection_xml.get('serverPort', None)
             connection_item.username = connection_xml.get('userName', None)
-            datasource_elem = connection_xml.find('.//t:datasource', namespaces=NAMESPACE)
+            datasource_elem = connection_xml.find('.//t:datasource', namespaces=ns)
             if datasource_elem is not None:
                 connection_item._datasource_id = datasource_elem.get('id', None)
                 connection_item._datasource_name = datasource_elem.get('name', None)

tableauserverclient/models/datasource_item.py

@@ -2,7 +2,6 @@
 from .exceptions import UnpopulatedPropertyError
 from .property_decorators import property_not_nullable, property_is_boolean
 from .tag_item import TagItem
-from .. import NAMESPACE
 from ..datetime_helpers import parse_datetime
 import copy
 
@@ -85,12 +84,12 @@ def updated_at(self):
     def _set_connections(self, connections):
         self._connections = connections
 
-    def _parse_common_elements(self, datasource_xml):
+    def _parse_common_elements(self, datasource_xml, ns):
         if not isinstance(datasource_xml, ET.Element):
-            datasource_xml = ET.fromstring(datasource_xml).find('.//t:datasource', namespaces=NAMESPACE)
+            datasource_xml = ET.fromstring(datasource_xml).find('.//t:datasource', namespaces=ns)
         if datasource_xml is not None:
             (_, _, _, _, _, updated_at, _, project_id, project_name, owner_id,
-             certified, certification_note) = self._parse_element(datasource_xml)
+             certified, certification_note) = self._parse_element(datasource_xml, ns)
             self._set_values(None, None, None, None, None, updated_at, None, project_id,
                              project_name, owner_id, certified, certification_note)
         return self
@@ -123,23 +122,23 @@ def _set_values(self, id, name, datasource_type, content_url, created_at,
         self.certified = certified  # Always True/False, not conditional
 
     @classmethod
-    def from_response(cls, resp):
+    def from_response(cls, resp, ns):
         all_datasource_items = list()
         parsed_response = ET.fromstring(resp)
-        all_datasource_xml = parsed_response.findall('.//t:datasource', namespaces=NAMESPACE)
+        all_datasource_xml = parsed_response.findall('.//t:datasource', namespaces=ns)
 
         for datasource_xml in all_datasource_xml:
             (id_, name, datasource_type, content_url, created_at, updated_at,
              tags, project_id, project_name, owner_id,
-             certified, certification_note) = cls._parse_element(datasource_xml)
+             certified, certification_note) = cls._parse_element(datasource_xml, ns)
             datasource_item = cls(project_id)
             datasource_item._set_values(id_, name, datasource_type, content_url, created_at, updated_at,
                                         tags, None, project_name, owner_id, certified, certification_note)
             all_datasource_items.append(datasource_item)
         return all_datasource_items
 
     @staticmethod
-    def _parse_element(datasource_xml):
+    def _parse_element(datasource_xml, ns):
         id_ = datasource_xml.get('id', None)
         name = datasource_xml.get('name', None)
         datasource_type = datasource_xml.get('type', None)
@@ -150,19 +149,19 @@ def _parse_element(datasource_xml):
         certified = str(datasource_xml.get('isCertified', None)).lower() == 'true'
 
         tags = None
-        tags_elem = datasource_xml.find('.//t:tags', namespaces=NAMESPACE)
+        tags_elem = datasource_xml.find('.//t:tags', namespaces=ns)
         if tags_elem is not None:
-            tags = TagItem.from_xml_element(tags_elem)
+            tags = TagItem.from_xml_element(tags_elem, ns)
 
         project_id = None
         project_name = None
-        project_elem = datasource_xml.find('.//t:project', namespaces=NAMESPACE)
+        project_elem = datasource_xml.find('.//t:project', namespaces=ns)
         if project_elem is not None:
             project_id = project_elem.get('id', None)
             project_name = project_elem.get('name', None)
 
         owner_id = None
-        owner_elem = datasource_xml.find('.//t:owner', namespaces=NAMESPACE)
+        owner_elem = datasource_xml.find('.//t:owner', namespaces=ns)
         if owner_elem is not None:
             owner_id = owner_elem.get('id', None)
 

tableauserverclient/models/fileupload_item.py

@@ -1,5 +1,4 @@
 import xml.etree.ElementTree as ET
-from .. import NAMESPACE
 
 
 class FileuploadItem(object):
@@ -16,9 +15,9 @@ def file_size(self):
         return self._file_size
 
     @classmethod
-    def from_response(cls, resp):
+    def from_response(cls, resp, ns):
         parsed_response = ET.fromstring(resp)
-        fileupload_elem = parsed_response.find('.//t:fileUpload', namespaces=NAMESPACE)
+        fileupload_elem = parsed_response.find('.//t:fileUpload', namespaces=ns)
         fileupload_item = cls()
         fileupload_item._upload_session_id = fileupload_elem.get('uploadSessionId', None)
         fileupload_item._file_size = fileupload_elem.get('fileSize', None)

tableauserverclient/models/group_item.py

@@ -1,7 +1,6 @@
 import xml.etree.ElementTree as ET
 from .exceptions import UnpopulatedPropertyError
 from .property_decorators import property_not_empty
-from .. import NAMESPACE
 
 
 class GroupItem(object):
@@ -40,16 +39,16 @@ def _set_users(self, users):
         self._users = users
 
     @classmethod
-    def from_response(cls, resp):
+    def from_response(cls, resp, ns):
         all_group_items = list()
         parsed_response = ET.fromstring(resp)
-        all_group_xml = parsed_response.findall('.//t:group', namespaces=NAMESPACE)
+        all_group_xml = parsed_response.findall('.//t:group', namespaces=ns)
         for group_xml in all_group_xml:
             name = group_xml.get('name', None)
             group_item = cls(name)
             group_item._id = group_xml.get('id', None)
 
-            domain_elem = group_xml.find('.//t:domain', namespaces=NAMESPACE)
+            domain_elem = group_xml.find('.//t:domain', namespaces=ns)
             if domain_elem is not None:
                 group_item._domain_name = domain_elem.get('name', None)
             all_group_items.append(group_item)

tableauserverclient/models/pagination_item.py

@@ -1,5 +1,4 @@
 import xml.etree.ElementTree as ET
-from .. import NAMESPACE
 
 
 class PaginationItem(object):
@@ -21,9 +20,9 @@ def total_available(self):
         return self._total_available
 
     @classmethod
-    def from_response(cls, resp):
+    def from_response(cls, resp, ns):
         parsed_response = ET.fromstring(resp)
-        pagination_xml = parsed_response.find('t:pagination', namespaces=NAMESPACE)
+        pagination_xml = parsed_response.find('t:pagination', namespaces=ns)
         pagination_item = cls()
         if pagination_xml is not None:
             pagination_item._page_number = int(pagination_xml.get('pageNumber', '-1'))

tableauserverclient/models/project_item.py

@@ -1,6 +1,5 @@
 import xml.etree.ElementTree as ET
 from .property_decorators import property_is_enum, property_not_empty
-from .. import NAMESPACE
 
 
 class ProjectItem(object):
@@ -63,10 +62,10 @@ def _set_values(self, project_id, name, description, content_permissions, parent
             self.parent_id = parent_id
 
     @classmethod
-    def from_response(cls, resp):
+    def from_response(cls, resp, ns):
         all_project_items = list()
         parsed_response = ET.fromstring(resp)
-        all_project_xml = parsed_response.findall('.//t:project', namespaces=NAMESPACE)
+        all_project_xml = parsed_response.findall('.//t:project', namespaces=ns)
 
         for project_xml in all_project_xml:
             (id, name, description, content_permissions, parent_id) = cls._parse_element(project_xml)

tableauserverclient/models/schedule_item.py

@@ -3,7 +3,6 @@
 
 from .interval_item import IntervalItem, HourlyInterval, DailyInterval, WeeklyInterval, MonthlyInterval
 from .property_decorators import property_is_enum, property_not_nullable, property_is_int
-from .. import NAMESPACE
 from ..datetime_helpers import parse_datetime
 
 
@@ -102,12 +101,13 @@ def state(self, value):
     def updated_at(self):
         return self._updated_at
 
-    def _parse_common_tags(self, schedule_xml):
+    def _parse_common_tags(self, schedule_xml, ns):
         if not isinstance(schedule_xml, ET.Element):
-            schedule_xml = ET.fromstring(schedule_xml).find('.//t:schedule', namespaces=NAMESPACE)
+            print(ns)
+            schedule_xml = ET.fromstring(schedule_xml).find('.//t:schedule', namespaces=ns)
         if schedule_xml is not None:
             (_, name, _, _, updated_at, _, next_run_at, end_schedule_at, execution_order,
-             priority, interval_item) = self._parse_element(schedule_xml)
+             priority, interval_item) = self._parse_element(schedule_xml, ns)
 
             self._set_values(id_=None,
                              name=name,
@@ -149,17 +149,17 @@ def _set_values(self, id_, name, state, created_at, updated_at, schedule_type,
             self._interval_item = interval_item
 
     @classmethod
-    def from_response(cls, resp):
+    def from_response(cls, resp, ns):
         parsed_response = ET.fromstring(resp)
-        return cls.from_element(parsed_response)
+        return cls.from_element(parsed_response, ns)
 
     @classmethod
-    def from_element(cls, parsed_response):
+    def from_element(cls, parsed_response, ns):
         all_schedule_items = []
-        all_schedule_xml = parsed_response.findall('.//t:schedule', namespaces=NAMESPACE)
+        all_schedule_xml = parsed_response.findall('.//t:schedule', namespaces=ns)
         for schedule_xml in all_schedule_xml:
             (id_, name, state, created_at, updated_at, schedule_type, next_run_at,
-             end_schedule_at, execution_order, priority, interval_item) = cls._parse_element(schedule_xml)
+             end_schedule_at, execution_order, priority, interval_item) = cls._parse_element(schedule_xml, ns)
 
             schedule_item = cls(name, priority, schedule_type, execution_order, interval_item)
 
@@ -179,13 +179,13 @@ def from_element(cls, parsed_response):
         return all_schedule_items
 
     @staticmethod
-    def _parse_interval_item(parsed_response, frequency):
+    def _parse_interval_item(parsed_response, frequency, ns):
         start_time = parsed_response.get("start", None)
         start_time = datetime.strptime(start_time, "%H:%M:%S").time()
         end_time = parsed_response.get("end", None)
         if end_time is not None:
             end_time = datetime.strptime(end_time, "%H:%M:%S").time()
-        interval_elems = parsed_response.findall(".//t:intervals/t:interval", namespaces=NAMESPACE)
+        interval_elems = parsed_response.findall(".//t:intervals/t:interval", namespaces=ns)
         interval = []
         for interval_elem in interval_elems:
             interval.extend(interval_elem.attrib.items())
@@ -212,7 +212,7 @@ def _parse_interval_item(parsed_response, frequency):
             return MonthlyInterval(start_time, interval_value)
 
     @staticmethod
-    def _parse_element(schedule_xml):
+    def _parse_element(schedule_xml, ns):
         id = schedule_xml.get('id', None)
         name = schedule_xml.get('name', None)
         state = schedule_xml.get('state', None)
@@ -229,9 +229,9 @@ def _parse_element(schedule_xml):
             priority = int(priority)
 
         interval_item = None
-        frequency_detail_elem = schedule_xml.find('.//t:frequencyDetails', namespaces=NAMESPACE)
+        frequency_detail_elem = schedule_xml.find('.//t:frequencyDetails', namespaces=ns)
         if frequency_detail_elem is not None:
-            interval_item = ScheduleItem._parse_interval_item(frequency_detail_elem, frequency)
+            interval_item = ScheduleItem._parse_interval_item(frequency_detail_elem, frequency, ns)
 
         return id, name, state, created_at, updated_at, schedule_type, \
             next_run_at, end_schedule_at, execution_order, priority, interval_item

tableauserverclient/models/server_info_item.py

@@ -1,5 +1,4 @@
 import xml.etree.ElementTree as ET
-from .. import NAMESPACE
 
 
 class ServerInfoItem(object):
@@ -21,10 +20,10 @@ def rest_api_version(self):
         return self._rest_api_version
 
     @classmethod
-    def from_response(cls, resp):
+    def from_response(cls, resp, ns):
         parsed_response = ET.fromstring(resp)
-        product_version_tag = parsed_response.find('.//t:productVersion', namespaces=NAMESPACE)
-        rest_api_version_tag = parsed_response.find('.//t:restApiVersion', namespaces=NAMESPACE)
+        product_version_tag = parsed_response.find('.//t:productVersion', namespaces=ns)
+        rest_api_version_tag = parsed_response.find('.//t:restApiVersion', namespaces=ns)
 
         build_number = product_version_tag.get('build', None)
         product_version = product_version_tag.text

tableauserverclient/models/site_item.py

@@ -1,7 +1,6 @@
 import xml.etree.ElementTree as ET
 from .property_decorators import (property_is_enum, property_is_boolean, property_matches,
                                   property_not_empty, property_not_nullable, property_is_int)
-from .. import NAMESPACE
 
 
 VALID_CONTENT_URL_RE = r"^[a-zA-Z0-9_\-]*$"
@@ -127,13 +126,13 @@ def subscribe_others_enabled(self, value):
     def is_default(self):
         return self.name.lower() == 'default'
 
-    def _parse_common_tags(self, site_xml):
+    def _parse_common_tags(self, site_xml, ns):
         if not isinstance(site_xml, ET.Element):
-            site_xml = ET.fromstring(site_xml).find('.//t:site', namespaces=NAMESPACE)
+            site_xml = ET.fromstring(site_xml).find('.//t:site', namespaces=ns)
         if site_xml is not None:
             (_, name, content_url, _, admin_mode, state,
              subscribe_others_enabled, disable_subscriptions, revision_history_enabled,
-             user_quota, storage_quota, revision_limit, num_users, storage) = self._parse_element(site_xml)
+             user_quota, storage_quota, revision_limit, num_users, storage) = 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,
@@ -173,14 +172,14 @@ def _set_values(self, id, name, content_url, status_reason, admin_mode, state,
             self._storage = storage
 
     @classmethod
-    def from_response(cls, resp):
+    def from_response(cls, resp, ns):
         all_site_items = list()
         parsed_response = ET.fromstring(resp)
-        all_site_xml = parsed_response.findall('.//t:site', namespaces=NAMESPACE)
+        all_site_xml = parsed_response.findall('.//t:site', namespaces=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) = cls._parse_element(site_xml)
+                revision_limit, num_users, storage) = 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,
@@ -190,7 +189,7 @@ def from_response(cls, resp):
         return all_site_items
 
     @staticmethod
-    def _parse_element(site_xml):
+    def _parse_element(site_xml, ns):
         id = site_xml.get('id', None)
         name = site_xml.get('name', None)
         content_url = site_xml.get('contentUrl', None)
@@ -215,7 +214,7 @@ def _parse_element(site_xml):
 
         num_users = None
         storage = None
-        usage_elem = site_xml.find('.//t:usage', namespaces=NAMESPACE)
+        usage_elem = site_xml.find('.//t:usage', namespaces=ns)
         if usage_elem is not None:
             num_users = usage_elem.get('numUsers', None)
             storage = usage_elem.get('storage', None)