Squashed commit of the following:

commit ad57851
Author: jorwoods <[email protected]>
Date:   Thu Nov 11 15:55:01 2021 -0600

    Jorwoods/type hint revisions (tableau#956)

    Add type hints and tests for workbook and data source revisions

commit bb0feb8
Author: elsherif <[email protected]>
Date:   Wed Nov 10 01:21:16 2021 +0100

    Add support to datasource and workbook revisions (tableau#931)

    * add support to datasource and workbook revisions (get all item revisions / downlad item by revision number)

    * add type hints

    * remove wrong type hints

commit 31d420f
Author: Stephen Mitchell <[email protected]>
Date:   Tue Nov 9 01:02:14 2021 -0500

    Clean up hidden_views by making it an attribute of WorkbookItem (tableau#617)

    * Clean up hidden views and make it an attribute of workbookitem

    * Pycodestyle error fix for one letter variable

    Co-authored-by: Jac <[email protected]>
    Co-authored by: Stephen Mitchell https://github.com/scuml

commit 7443f68
Author: jorwoods <[email protected]>
Date:   Sun Nov 7 05:57:42 2021 -0600

    Add type hints to `Job` (tableau#939)

commit c8170ae
Author: Tyler Doyle <[email protected]>
Date:   Mon Nov 1 20:36:17 2021 -0400

    Fix slack once and for all (tableau#946)

    The red X keeps coming back so I'd like to mark this as allowably fail-able -- that way the innards of Slack/OAuth/Tableau credentials don't keep polluting test run reports :)

Author: jorwoods

.github/workflows/slack.yml

@@ -9,6 +9,7 @@ jobs:
     name: Sends a message to Slack when a push, a pull request or an issue is made
     steps:
       - name: Send message to Slack API
+        continue-on-error: true
         uses: archive/[email protected]
         id: notify
         with:

tableauserverclient/__init__.py

@@ -34,7 +34,8 @@
     FlowItem,
     WebhookItem,
     PersonalAccessTokenAuth,
-    FlowRunItem
+    FlowRunItem,
+    RevisionItem
 )
 from .server import (
     RequestOptions,

tableauserverclient/models/__init__.py

@@ -36,3 +36,4 @@
 from .permissions_item import PermissionsRule, Permission
 from .webhook_item import WebhookItem
 from .personal_access_token_auth import PersonalAccessTokenAuth
+from .revision_item import RevisionItem

tableauserverclient/models/datasource_item.py

@@ -14,6 +14,7 @@
 if TYPE_CHECKING:
     from .permissions_item import PermissionsRule
     from .connection_item import ConnectionItem
+    from .revision_item import RevisionItem
     import datetime
 
 
@@ -37,6 +38,7 @@ def __init__(self, project_id: str, name: str = None) -> None:
         self._id: Optional[str] = None
         self._initial_tags: Set = set()
         self._project_name: Optional[str] = None
+        self._revisions = None
         self._updated_at = None
         self._use_remote_query_agent = None
         self._webpage_url = None
@@ -166,6 +168,13 @@ def use_remote_query_agent(self, value: bool):
     def webpage_url(self) -> Optional[str]:
         return self._webpage_url
 
+    @property
+    def revisions(self) -> List["RevisionItem"]:
+        if self._revisions is None:
+            error = "Datasource item must be populated with revisions first."
+            raise UnpopulatedPropertyError(error)
+        return self._revisions()
+
     def _set_connections(self, connections):
         self._connections = connections
 
@@ -175,6 +184,9 @@ def _set_permissions(self, permissions):
     def _set_data_quality_warnings(self, dqws):
         self._data_quality_warnings = dqws
 
+    def _set_revisions(self, revisions):
+        self._revisions = revisions
+
     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=ns)

tableauserverclient/models/job_item.py

@@ -3,29 +3,35 @@
 from ..datetime_helpers import parse_datetime
 
 
+from typing import List, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import datetime
+
+
 class JobItem(object):
     class FinishCode:
         """
         Status codes as documented on
         https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_jobs_tasks_and_schedules.htm#query_job
         """
 
-        Success = 0
-        Failed = 1
-        Cancelled = 2
+        Success: int = 0
+        Failed: int = 1
+        Cancelled: int = 2
 
     def __init__(
         self,
-        id_,
-        job_type,
-        progress,
-        created_at,
-        started_at=None,
-        completed_at=None,
-        finish_code=0,
-        notes=None,
-        mode=None,
-        flow_run=None,
+        id_: str,
+        job_type: str,
+        progress: str,
+        created_at: "datetime.datetime",
+        started_at: Optional["datetime.datetime"] = None,
+        completed_at: Optional["datetime.datetime"] = None,
+        finish_code: int = 0,
+        notes: Optional[List[str]] = None,
+        mode: Optional[str] = None,
+        flow_run: Optional[FlowRunItem] = None
     ):
         self._id = id_
         self._type = job_type
@@ -34,48 +40,48 @@ def __init__(
         self._started_at = started_at
         self._completed_at = completed_at
         self._finish_code = finish_code
-        self._notes = notes or []
+        self._notes: List[str] = notes or []
         self._mode = mode
         self._flow_run = flow_run
 
     @property
-    def id(self):
+    def id(self) -> str:
         return self._id
 
     @property
-    def type(self):
+    def type(self) -> str:
         return self._type
 
     @property
-    def progress(self):
+    def progress(self) -> str:
         return self._progress
 
     @property
-    def created_at(self):
+    def created_at(self) -> "datetime.datetime":
         return self._created_at
 
     @property
-    def started_at(self):
+    def started_at(self) -> Optional["datetime.datetime"]:
         return self._started_at
 
     @property
-    def completed_at(self):
+    def completed_at(self) -> Optional["datetime.datetime"]:
         return self._completed_at
 
     @property
-    def finish_code(self):
+    def finish_code(self) -> int:
         return self._finish_code
 
     @property
-    def notes(self):
+    def notes(self) -> List[str]:
         return self._notes
 
     @property
-    def mode(self):
+    def mode(self) -> Optional[str]:
         return self._mode
 
     @mode.setter
-    def mode(self, value):
+    def mode(self, value: str) -> None:
         # check for valid data here
         self._mode = value
 
@@ -94,7 +100,7 @@ def __repr__(self):
         )
 
     @classmethod
-    def from_response(cls, xml, ns):
+    def from_response(cls, xml, ns) -> List["JobItem"]:
         parsed_response = ET.fromstring(xml)
         all_tasks_xml = parsed_response.findall(".//t:job", namespaces=ns)
 
@@ -136,23 +142,23 @@ def _parse_element(cls, element, ns):
 
 class BackgroundJobItem(object):
     class Status:
-        Pending = "Pending"
-        InProgress = "InProgress"
-        Success = "Success"
-        Failed = "Failed"
-        Cancelled = "Cancelled"
+        Pending: str = "Pending"
+        InProgress: str = "InProgress"
+        Success: str = "Success"
+        Failed: str = "Failed"
+        Cancelled: str = "Cancelled"
 
     def __init__(
         self,
-        id_,
-        created_at,
-        priority,
-        job_type,
-        status,
-        title=None,
-        subtitle=None,
-        started_at=None,
-        ended_at=None,
+        id_: str,
+        created_at: "datetime.datetime",
+        priority: int,
+        job_type: str,
+        status: str,
+        title: Optional[str] = None,
+        subtitle: Optional[str] = None,
+        started_at: Optional["datetime.datetime"] = None,
+        ended_at: Optional["datetime.datetime"] = None,
     ):
         self._id = id_
         self._type = job_type
@@ -165,49 +171,49 @@ def __init__(
         self._subtitle = subtitle
 
     @property
-    def id(self):
+    def id(self) -> str:
         return self._id
 
     @property
-    def name(self):
+    def name(self) -> Optional[str]:
         """For API consistency - all other resource endpoints have a name attribute which is used to display what
         they are.  Alias title as name to allow consistent handling of resources in the list sample."""
         return self._title
 
     @property
-    def status(self):
+    def status(self) -> str:
         return self._status
 
     @property
-    def type(self):
+    def type(self) -> str:
         return self._type
 
     @property
-    def created_at(self):
+    def created_at(self) -> "datetime.datetime":
         return self._created_at
 
     @property
-    def started_at(self):
+    def started_at(self) -> Optional["datetime.datetime"]:
         return self._started_at
 
     @property
-    def ended_at(self):
+    def ended_at(self) -> Optional["datetime.datetime"]:
         return self._ended_at
 
     @property
-    def title(self):
+    def title(self) -> Optional[str]:
         return self._title
 
     @property
-    def subtitle(self):
+    def subtitle(self) -> Optional[str]:
         return self._subtitle
 
     @property
-    def priority(self):
+    def priority(self) -> int:
         return self._priority
 
     @classmethod
-    def from_response(cls, xml, ns):
+    def from_response(cls, xml, ns) -> List["BackgroundJobItem"]:
         parsed_response = ET.fromstring(xml)
         all_tasks_xml = parsed_response.findall(".//t:backgroundJob", namespaces=ns)
         return [cls._parse_element(x, ns) for x in all_tasks_xml]

tableauserverclient/models/revision_item.py

@@ -0,0 +1,85 @@
+import xml.etree.ElementTree as ET
+from ..datetime_helpers import parse_datetime
+from typing import List, Optional, TYPE_CHECKING, Type
+
+if TYPE_CHECKING:
+    from datetime import datetime
+
+class RevisionItem(object):
+    def __init__(self):
+        self._resource_id: Optional[str] = None
+        self._resource_name: Optional[str] = None
+        self._revision_number: Optional[str] = None
+        self._current: Optional[bool] = None
+        self._deleted: Optional[bool] = None
+        self._created_at: Optional["datetime"] = None
+        self._user_id: Optional[str] = None
+        self._user_name: Optional[str] = None
+
+    @property
+    def resource_id(self) -> Optional[str]:
+        return self._resource_id
+
+    @property
+    def resource_name(self) -> Optional[str]:
+        return self._resource_name
+
+    @property
+    def revision_number(self) -> Optional[str]:
+        return self._revision_number
+
+    @property
+    def current(self) -> Optional[bool]:
+        return self._current
+
+    @property
+    def deleted(self) -> Optional[bool]:
+        return self._deleted
+
+    @property
+    def created_at(self) -> Optional["datetime"]:
+        return self._created_at
+
+    @property
+    def user_id(self) -> Optional[str]:
+        return self._user_id
+
+    @property
+    def user_name(self) -> Optional[str]:
+        return self._user_name
+
+    def __repr__(self):
+        return (
+            "<RevisionItem# revisionNumber={_revision_number} "
+            "current={_current} deleted={_deleted} user={_user_id}>".format(**self.__dict__)
+        )
+
+    @classmethod
+    def from_response(
+        cls,
+        resp: bytes,
+        ns,
+        resource_item
+    ) -> List["RevisionItem"]:
+        all_revision_items = list()
+        parsed_response = ET.fromstring(resp)
+        all_revision_xml = parsed_response.findall(".//t:revision", namespaces=ns)
+        for revision_xml in all_revision_xml:
+            revision_item = cls()
+            revision_item._resource_id = resource_item.id
+            revision_item._resource_name = resource_item.name
+            revision_item._revision_number = revision_xml.get("revisionNumber", None)
+            revision_item._current = string_to_bool(revision_xml.get("isCurrent", ""))
+            revision_item._deleted = string_to_bool(revision_xml.get("isDeleted", ""))
+            revision_item._created_at = parse_datetime(revision_xml.get("createdAt", None))
+            for user in revision_xml.findall('.//t:user', namespaces=ns):
+                revision_item._user_id = user.get("id", None)
+                revision_item._user_name = user.get("name", None)
+
+            all_revision_items.append(revision_item)
+        return all_revision_items
+
+
+# Used to convert string represented boolean to a boolean type
+def string_to_bool(s: str) -> bool:
+    return s.lower() == "true"