fix: merge conflict

Author: jorwoods

tableauserverclient/__init__.py

@@ -2,6 +2,7 @@
 from tableauserverclient.namespace import NEW_NAMESPACE as DEFAULT_NAMESPACE
 from tableauserverclient.models import (
     BackgroundJobItem,
+    CollectionItem,
     ColumnItem,
     ConnectionCredentials,
     ConnectionItem,
@@ -73,7 +74,7 @@
 
 __all__ = [
     "BackgroundJobItem",
-    "BackgroundJobItem",
+    "CollectionItem",
     "ColumnItem",
     "ConnectionCredentials",
     "ConnectionItem",

tableauserverclient/models/__init__.py

@@ -1,3 +1,4 @@
+from tableauserverclient.models.collection_item import CollectionItem
 from tableauserverclient.models.column_item import ColumnItem
 from tableauserverclient.models.connection_credentials import ConnectionCredentials
 from tableauserverclient.models.connection_item import ConnectionItem
@@ -53,6 +54,7 @@
 from tableauserverclient.models.extract_item import ExtractItem
 
 __all__ = [
+    "CollectionItem",
     "ColumnItem",
     "ConnectionCredentials",
     "ConnectionItem",

tableauserverclient/models/collection_item.py

@@ -0,0 +1,52 @@
+from datetime import datetime
+from typing import Optional
+from xml.etree.ElementTree import Element
+
+from defusedxml.ElementTree import fromstring
+from typing_extensions import Self
+
+from tableauserverclient.datetime_helpers import parse_datetime
+from tableauserverclient.models.user_item import UserItem
+
+
+class CollectionItem:
+    def __init__(self) -> None:
+        self.id: Optional[str] = None
+        self.name: Optional[str] = None
+        self.description: Optional[str] = None
+        self.created_at: Optional[datetime] = None
+        self.updated_at: Optional[datetime] = None
+        self.owner: Optional[UserItem] = None
+        self.total_item_count: Optional[int] = None
+        self.permissioned_item_count: Optional[int] = None
+        self.visibility: Optional[str] = None  # Assuming visibility is a string, adjust as necessary
+
+    @classmethod
+    def from_response(cls, response: bytes, ns) -> list[Self]:
+        parsed_response = fromstring(response)
+
+        collection_elements = parsed_response.findall(".//t:collection", namespaces=ns)
+        if not collection_elements:
+            raise ValueError("No collection element found in the response")
+
+        collections = [cls.from_xml(c, ns) for c in collection_elements]
+        return collections
+
+    @classmethod
+    def from_xml(cls, xml: Element, ns) -> Self:
+        collection_item = cls()
+        collection_item.id = xml.get("id")
+        collection_item.name = xml.get("name")
+        collection_item.description = xml.get("description")
+        collection_item.created_at = parse_datetime(xml.get("createdAt"))
+        collection_item.updated_at = parse_datetime(xml.get("updatedAt"))
+        owner_element = xml.find(".//t:owner", namespaces=ns)
+        if owner_element is not None:
+            collection_item.owner = UserItem.from_xml(owner_element, ns)
+        else:
+            collection_item.owner = None
+        collection_item.total_item_count = int(xml.get("totalItemCount", 0))
+        collection_item.permissioned_item_count = int(xml.get("permissionedItemCount", 0))
+        collection_item.visibility = xml.get("visibility")
+
+        return collection_item

tableauserverclient/models/datasource_item.py

@@ -490,7 +490,7 @@ def _set_values(
             self._owner = owner
 
     @classmethod
-    def from_response(cls, resp: str, ns: dict) -> list["DatasourceItem"]:
+    def from_response(cls, resp: bytes, ns: dict) -> list["DatasourceItem"]:
         all_datasource_items = list()
         parsed_response = fromstring(resp)
         all_datasource_xml = parsed_response.findall(".//t:datasource", namespaces=ns)

tableauserverclient/models/favorites_item.py

@@ -1,9 +1,8 @@
 import logging
 
-from typing import Union
+from typing import TypedDict, Union
 from defusedxml.ElementTree import fromstring
-
-from tableauserverclient.models.tableau_types import TableauItem
+from tableauserverclient.models.collection_item import CollectionItem
 from tableauserverclient.models.datasource_item import DatasourceItem
 from tableauserverclient.models.flow_item import FlowItem
 from tableauserverclient.models.project_item import ProjectItem
@@ -13,16 +12,22 @@
 
 from tableauserverclient.helpers.logging import logger
 
-FavoriteType = dict[
-    str,
-    list[TableauItem],
-]
+
+class FavoriteType(TypedDict):
+    collections: list[CollectionItem]
+    datasources: list[DatasourceItem]
+    flows: list[FlowItem]
+    projects: list[ProjectItem]
+    metrics: list[MetricItem]
+    views: list[ViewItem]
+    workbooks: list[WorkbookItem]
 
 
 class FavoriteItem:
     @classmethod
     def from_response(cls, xml: Union[str, bytes], namespace: dict) -> FavoriteType:
         favorites: FavoriteType = {
+            "collections": [],
             "datasources": [],
             "flows": [],
             "projects": [],
@@ -32,6 +37,7 @@ def from_response(cls, xml: Union[str, bytes], namespace: dict) -> FavoriteType:
         }
         parsed_response = fromstring(xml)
 
+        collections_xml = parsed_response.findall(".//t:favorite/t:collection", namespace)
         datasources_xml = parsed_response.findall(".//t:favorite/t:datasource", namespace)
         flows_xml = parsed_response.findall(".//t:favorite/t:flow", namespace)
         metrics_xml = parsed_response.findall(".//t:favorite/t:metric", namespace)
@@ -40,13 +46,14 @@ def from_response(cls, xml: Union[str, bytes], namespace: dict) -> FavoriteType:
         workbooks_xml = parsed_response.findall(".//t:favorite/t:workbook", namespace)
 
         logger.debug(
-            "ds: {}, flows: {}, metrics: {}, projects: {}, views: {}, wbs: {}".format(
+            "ds: {}, flows: {}, metrics: {}, projects: {}, views: {}, wbs: {}, collections: {}".format(
                 len(datasources_xml),
                 len(flows_xml),
                 len(metrics_xml),
                 len(projects_xml),
                 len(views_xml),
                 len(workbooks_xml),
+                len(collections_xml),
             )
         )
         for datasource in datasources_xml:
@@ -85,5 +92,11 @@ def from_response(cls, xml: Union[str, bytes], namespace: dict) -> FavoriteType:
                 logger.debug(fav_workbook)
                 favorites["workbooks"].append(fav_workbook)
 
+        for collection in collections_xml:
+            fav_collection = CollectionItem.from_xml(collection, namespace)
+            if fav_collection:
+                logger.debug(fav_collection)
+                favorites["collections"].append(fav_collection)
+
         logger.debug(favorites)
         return favorites

tableauserverclient/models/permissions_item.py

@@ -44,6 +44,7 @@ class Capability:
         SaveAs = "SaveAs"
         PulseMetricDefine = "PulseMetricDefine"
         ExtractRefresh = "ExtractRefresh"
+        WebAuthoringForFlows = "WebAuthoringForFlows"
 
         def __repr__(self):
             return "<Enum Capability: AddComment | ChangeHierarchy | ChangePermission ... (17 more) >"

tableauserverclient/models/user_item.py

@@ -17,6 +17,7 @@
 
 if TYPE_CHECKING:
     from tableauserverclient.server import Pager
+    from tableauserverclient.models.favorites_item import FavoriteType
 
 
 class UserItem:
@@ -131,7 +132,7 @@ def __init__(
         self._id: Optional[str] = None
         self._last_login: Optional[datetime] = None
         self._workbooks = None
-        self._favorites: Optional[dict[str, list]] = None
+        self._favorites: Optional["FavoriteType"] = None
         self._groups = None
         self.email: Optional[str] = None
         self.fullname: Optional[str] = None
@@ -218,7 +219,7 @@ def workbooks(self) -> "Pager":
         return self._workbooks()
 
     @property
-    def favorites(self) -> dict[str, list]:
+    def favorites(self) -> "FavoriteType":
         if self._favorites is None:
             error = "User item must be populated with favorites first."
             raise UnpopulatedPropertyError(error)

tableauserverclient/server/endpoint/datasources_endpoint.py

@@ -6,8 +6,8 @@
 
 from contextlib import closing
 from pathlib import Path
-from typing import Literal, Optional, TYPE_CHECKING, Union, overload
-from collections.abc import Iterable, Mapping, Sequence
+from typing import Literal, Optional, TYPE_CHECKING, TypedDict, TypeVar, Union, overload
+from collections.abc import Iterable, Sequence
 
 from tableauserverclient.helpers.headers import fix_filename
 from tableauserverclient.models.dqw_item import DQWItem
@@ -50,13 +50,50 @@
 FileObject = Union[io.BufferedReader, io.BytesIO]
 PathOrFile = Union[FilePath, FileObject]
 
-FilePath = Union[str, os.PathLike]
 FileObjectR = Union[io.BufferedReader, io.BytesIO]
 FileObjectW = Union[io.BufferedWriter, io.BytesIO]
 PathOrFileR = Union[FilePath, FileObjectR]
 PathOrFileW = Union[FilePath, FileObjectW]
 
 
+HyperActionCondition = TypedDict(
+    "HyperActionCondition",
+    {
+        "op": str,
+        "target-col": str,
+        "source-col": str,
+    },
+)
+
+HyperActionRow = TypedDict(
+    "HyperActionRow",
+    {
+        "action": Literal[
+            "update",
+            "upsert",
+            "delete",
+        ],
+        "source-table": str,
+        "target-table": str,
+        "condition": HyperActionCondition,
+    },
+)
+
+HyperActionTable = TypedDict(
+    "HyperActionTable",
+    {
+        "action": Literal[
+            "insert",
+            "replace",
+        ],
+        "source-table": str,
+        "target-table": str,
+    },
+)
+
+HyperAction = Union[HyperActionTable, HyperActionRow]
+
+
 class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]):
     def __init__(self, parent_srv: "Server") -> None:
         super().__init__(parent_srv)
@@ -191,16 +228,34 @@ def delete(self, datasource_id: str) -> None:
         self.delete_request(url)
         logger.info(f"Deleted single datasource (ID: {datasource_id})")
 
+    T = TypeVar("T", bound=FileObjectW)
+
+    @overload
+    def download(
+        self,
+        datasource_id: str,
+        filepath: T,
+        include_extract: bool = True,
+    ) -> T: ...
+
+    @overload
+    def download(
+        self,
+        datasource_id: str,
+        filepath: Optional[FilePath] = None,
+        include_extract: bool = True,
+    ) -> str: ...
+
     # Download 1 datasource by id
     @api(version="2.0")
     @parameter_added_in(no_extract="2.5")
     @parameter_added_in(include_extract="2.5")
     def download(
         self,
-        datasource_id: str,
-        filepath: Optional[PathOrFileW] = None,
-        include_extract: bool = True,
-    ) -> PathOrFileW:
+        datasource_id,
+        filepath=None,
+        include_extract=True,
+    ):
         """
         Downloads the specified data source from a site. The data source is
         downloaded as a .tdsx file.
@@ -479,13 +534,13 @@ def publish(
     @parameter_added_in(as_job="3.0")
     def publish(
         self,
-        datasource_item: DatasourceItem,
-        file: PathOrFileR,
-        mode: str,
-        connection_credentials: Optional[ConnectionCredentials] = None,
-        connections: Optional[Sequence[ConnectionItem]] = None,
-        as_job: bool = False,
-    ) -> Union[DatasourceItem, JobItem]:
+        datasource_item,
+        file,
+        mode,
+        connection_credentials=None,
+        connections=None,
+        as_job=False,
+    ):
         """
         Publishes a data source to a server, or appends data to an existing
         data source.
@@ -631,7 +686,7 @@ def update_hyper_data(
         datasource_or_connection_item: Union[DatasourceItem, ConnectionItem, str],
         *,
         request_id: str,
-        actions: Sequence[Mapping],
+        actions: Sequence[HyperAction],
         payload: Optional[FilePath] = None,
     ) -> JobItem:
         """
@@ -898,15 +953,35 @@ def _get_datasource_revisions(
         revisions = RevisionItem.from_response(server_response.content, self.parent_srv.namespace, datasource_item)
         return revisions
 
-    # Download 1 datasource revision by revision number
-    @api(version="2.3")
+    T = TypeVar("T", bound=FileObjectW)
+
+    @overload
+    def download_revision(
+        self,
+        datasource_id: str,
+        revision_number: Optional[str],
+        filepath: T,
+        include_extract: bool = True,
+    ) -> T: ...
+
+    @overload
     def download_revision(
         self,
         datasource_id: str,
         revision_number: Optional[str],
-        filepath: Optional[PathOrFileW] = None,
+        filepath: Optional[FilePath] = None,
         include_extract: bool = True,
-    ) -> PathOrFileW:
+    ) -> str: ...
+
+    # Download 1 datasource revision by revision number
+    @api(version="2.3")
+    def download_revision(
+        self,
+        datasource_id,
+        revision_number,
+        filepath=None,
+        include_extract=True,
+    ):
         """
         Downloads a specific version of a data source prior to the current one
         in .tdsx format. To download the current version of a data source set

test/assets/favorites_get.xml

@@ -43,5 +43,17 @@
         <tags />
       </datasource>
     </favorite>
+    <favorite>
+      <collection id="8c57cb8a-d65f-4a32-813e-5a3f86e8f94e" 
+                  name="sample collection" 
+                  description="description for sample collection"
+                  totalItemCount="3"
+                  permissionedItemCount="2"
+                  visibility="Private"
+                  createdAt="2016-08-11T21:22:40Z" 
+                  updatedAt="2016-08-11T21:34:17Z">
+        <owner id="5de011f8-5aa9-4d5b-b991-f462c8dd6bb7" />
+      </collection>
+    </favorite>
   </favorites>
-</tsResponse>
+</tsResponse>