tableauserverclient 0.36__tar.gz → 0.38__tar.gz

{tableauserverclient-0.36 → tableauserverclient-0.38}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: tableauserverclient
-Version: 0.36
+Version: 0.38
 Summary: A Python module for working with the Tableau Server REST API.
 Author-email: Tableau <github@tableau.com>
 License: The MIT License (MIT)
@@ -50,6 +50,7 @@ Requires-Dist: pytest>=7.0; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: pytest-subtests; extra == "test"
 Requires-Dist: requests-mock<2.0,>=1.0; extra == "test"
+Dynamic: license-file
 
 # Tableau Server Client (Python)
 

{tableauserverclient-0.36 → tableauserverclient-0.38}/samples/extracts.py

@@ -42,7 +42,6 @@ def main():
     server.add_http_options({"verify": False})
     server.use_server_version()
     with server.auth.sign_in(tableau_auth):
-
         wb = None
         ds = None
         if args.workbook:

{tableauserverclient-0.36 → tableauserverclient-0.38}/tableauserverclient/__init__.py

@@ -25,6 +25,7 @@ from tableauserverclient.models import (
     LinkedTaskItem,
     LinkedTaskStepItem,
     LinkedTaskFlowRunItem,
+    LocationItem,
     MetricItem,
     MonthlyInterval,
     PaginationItem,
@@ -35,6 +36,7 @@ from tableauserverclient.models import (
     Resource,
     RevisionItem,
     ScheduleItem,
+    SiteAuthConfiguration,
     SiteItem,
     ServerInfoItem,
     SubscriptionItem,
@@ -56,6 +58,7 @@ from tableauserverclient.server import (
     ExcelRequestOptions,
     ImageRequestOptions,
     PDFRequestOptions,
+    PPTXRequestOptions,
     RequestOptions,
     MissingRequiredFieldError,
     FailedSignInError,
@@ -100,6 +103,7 @@ __all__ = [
     "LinkedTaskFlowRunItem",
     "LinkedTaskItem",
     "LinkedTaskStepItem",
+    "LocationItem",
     "MetricItem",
     "MissingRequiredFieldError",
     "MonthlyInterval",
@@ -107,6 +111,7 @@ __all__ = [
     "Pager",
     "PaginationItem",
     "PDFRequestOptions",
+    "PPTXRequestOptions",
     "Permission",
     "PermissionsRule",
     "PersonalAccessTokenAuth",
@@ -119,6 +124,7 @@ __all__ = [
     "ServerInfoItem",
     "ServerResponseError",
     "SiteItem",
+    "SiteAuthConfiguration",
     "Sort",
     "SubscriptionItem",
     "TableauAuth",

{tableauserverclient-0.36 → tableauserverclient-0.38}/tableauserverclient/bin/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-01-10T10:20:30-0800",
+ "date": "2025-05-15T14:21:50-0700",
  "dirty": false,
  "error": null,
- "full-revisionid": "42cecfe268d494284ca74b49aa4e9bfb6cfa197a",
- "version": "0.36"
+ "full-revisionid": "cda018b684c98200f3f9de11e379ba2ca3b1b3fe",
+ "version": "0.38"
 }
 '''  # END VERSION_JSON
 

{tableauserverclient-0.36 → tableauserverclient-0.38}/tableauserverclient/helpers/strings.py

@@ -1,6 +1,6 @@
 from defusedxml.ElementTree import fromstring, tostring
 from functools import singledispatch
-from typing import TypeVar
+from typing import TypeVar, overload
 
 
 # the redact method can handle either strings or bytes, but it can't mix them.
@@ -41,3 +41,27 @@ def _(xml: str) -> str:
 @redact_xml.register  # type: ignore[no-redef]
 def _(xml: bytes) -> bytes:
     return _redact_any_type(bytearray(xml), b"password", b"..[redacted]")
+
+
+@overload
+def nullable_str_to_int(value: None) -> None: ...
+
+
+@overload
+def nullable_str_to_int(value: str) -> int: ...
+
+
+def nullable_str_to_int(value):
+    return int(value) if value is not None else None
+
+
+@overload
+def nullable_str_to_bool(value: None) -> None: ...
+
+
+@overload
+def nullable_str_to_bool(value: str) -> bool: ...
+
+
+def nullable_str_to_bool(value):
+    return str(value).lower() == "true" if value is not None else None

{tableauserverclient-0.36 → tableauserverclient-0.38}/tableauserverclient/models/__init__.py

@@ -28,6 +28,7 @@ from tableauserverclient.models.linked_tasks_item import (
     LinkedTaskStepItem,
     LinkedTaskFlowRunItem,
 )
+from tableauserverclient.models.location_item import LocationItem
 from tableauserverclient.models.metric_item import MetricItem
 from tableauserverclient.models.pagination_item import PaginationItem
 from tableauserverclient.models.permissions_item import PermissionsRule, Permission
@@ -35,7 +36,7 @@ from tableauserverclient.models.project_item import ProjectItem
 from tableauserverclient.models.revision_item import RevisionItem
 from tableauserverclient.models.schedule_item import ScheduleItem
 from tableauserverclient.models.server_info_item import ServerInfoItem
-from tableauserverclient.models.site_item import SiteItem
+from tableauserverclient.models.site_item import SiteItem, SiteAuthConfiguration
 from tableauserverclient.models.subscription_item import SubscriptionItem
 from tableauserverclient.models.table_item import TableItem
 from tableauserverclient.models.tableau_auth import Credentials, TableauAuth, PersonalAccessTokenAuth, JWTAuth
@@ -48,6 +49,7 @@ from tableauserverclient.models.view_item import ViewItem
 from tableauserverclient.models.virtual_connection_item import VirtualConnectionItem
 from tableauserverclient.models.webhook_item import WebhookItem
 from tableauserverclient.models.workbook_item import WorkbookItem
+from tableauserverclient.models.extract_item import ExtractItem
 
 __all__ = [
     "ColumnItem",
@@ -75,6 +77,7 @@ __all__ = [
     "MonthlyInterval",
     "HourlyInterval",
     "BackgroundJobItem",
+    "LocationItem",
     "MetricItem",
     "PaginationItem",
     "Permission",
@@ -83,6 +86,7 @@ __all__ = [
     "RevisionItem",
     "ScheduleItem",
     "ServerInfoItem",
+    "SiteAuthConfiguration",
     "SiteItem",
     "SubscriptionItem",
     "TableItem",
@@ -103,4 +107,5 @@ __all__ = [
     "LinkedTaskItem",
     "LinkedTaskStepItem",
     "LinkedTaskFlowRunItem",
+    "ExtractItem",
 ]

{tableauserverclient-0.36 → tableauserverclient-0.38}/tableauserverclient/models/connection_item.py

@@ -103,11 +103,11 @@ class ConnectionItem:
         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._id = connection_xml.get("id", connection_xml.get("connectionId", None))
             connection_item._connection_type = connection_xml.get("type", connection_xml.get("dbClass", None))
             connection_item.embed_password = string_to_bool(connection_xml.get("embedPassword", ""))
-            connection_item.server_address = connection_xml.get("serverAddress", None)
-            connection_item.server_port = connection_xml.get("serverPort", None)
+            connection_item.server_address = connection_xml.get("serverAddress", connection_xml.get("server", None))
+            connection_item.server_port = connection_xml.get("serverPort", connection_xml.get("port", None))
             connection_item.username = connection_xml.get("userName", None)
             connection_item._query_tagging = (
                 string_to_bool(s) if (s := connection_xml.get("queryTagging", None)) else None

{tableauserverclient-0.36 → tableauserverclient-0.38}/tableauserverclient/models/datasource_item.py

@@ -6,9 +6,11 @@ from typing import Optional
 from defusedxml.ElementTree import fromstring
 
 from tableauserverclient.datetime_helpers import parse_datetime
+from tableauserverclient.helpers.strings import nullable_str_to_bool, nullable_str_to_int
 from tableauserverclient.models.connection_item import ConnectionItem
 from tableauserverclient.models.exceptions import UnpopulatedPropertyError
 from tableauserverclient.models.permissions_item import PermissionsRule
+from tableauserverclient.models.project_item import ProjectItem
 from tableauserverclient.models.property_decorators import (
     property_not_nullable,
     property_is_boolean,
@@ -16,9 +18,118 @@ from tableauserverclient.models.property_decorators import (
 )
 from tableauserverclient.models.revision_item import RevisionItem
 from tableauserverclient.models.tag_item import TagItem
+from tableauserverclient.models.user_item import UserItem
 
 
 class DatasourceItem:
+    """
+    Represents a Tableau datasource item.
+
+    Parameters
+    ----------
+    project_id : Optional[str]
+        The project ID that the datasource belongs to.
+
+    name : Optional[str]
+        The name of the datasource.
+
+    Attributes
+    ----------
+    ask_data_enablement : Optional[str]
+        Determines if a data source allows use of Ask Data. The value can be
+        TSC.DatasourceItem.AskDataEnablement.Enabled,
+        TSC.DatasourceItem.AskDataEnablement.Disabled, or
+        TSC.DatasourceItem.AskDataEnablement.SiteDefault. If no setting is
+        specified, it will default to SiteDefault. See REST API Publish
+        Datasource for more information about ask_data_enablement.
+
+    connected_workbooks_count : Optional[int]
+        The number of workbooks connected to the datasource.
+
+    connections : list[ConnectionItem]
+        The list of data connections (ConnectionItem) for the specified data
+        source. You must first call the populate_connections method to access
+        this data. See the ConnectionItem class.
+
+    content_url : Optional[str]
+        The name of the data source as it would appear in a URL.
+
+    created_at : Optional[datetime.datetime]
+        The time the data source was created.
+
+    certified : Optional[bool]
+        A Boolean value that indicates whether the data source is certified.
+
+    certification_note : Optional[str]
+        The optional note that describes the certified data source.
+
+    datasource_type : Optional[str]
+        The type of data source, for example, sqlserver or excel-direct.
+
+    description : Optional[str]
+        The description for the data source.
+
+    encrypt_extracts : Optional[bool]
+        A Boolean value to determine if a datasource should be encrypted or not.
+        See Extract and Encryption Methods for more information.
+
+    favorites_total : Optional[int]
+        The number of users who have marked the data source as a favorite.
+
+    has_alert : Optional[bool]
+        A Boolean value that indicates whether the data source has an alert.
+
+    has_extracts : Optional[bool]
+        A Boolean value that indicates whether the datasource has extracts.
+
+    id : Optional[str]
+        The identifier for the data source. You need this value to query a
+        specific data source or to delete a data source with the get_by_id and
+        delete methods.
+
+    is_published : Optional[bool]
+        A Boolean value that indicates whether the data source is published.
+
+    name : Optional[str]
+        The name of the data source. If not specified, the name of the published
+        data source file is used.
+
+    owner: Optional[UserItem]
+        The owner of the data source.
+
+    owner_id : Optional[str]
+        The identifier of the owner of the data source.
+
+    project : Optional[ProjectItem]
+        The project that the data source belongs to.
+
+    project_id : Optional[str]
+        The identifier of the project associated with the data source. You must
+        provide this identifier when you create an instance of a DatasourceItem.
+
+    project_name : Optional[str]
+        The name of the project associated with the data source.
+
+    server_name : Optional[str]
+        The name of the server where the data source is published.
+
+    tags : Optional[set[str]]
+        The tags (list of strings) that have been added to the data source.
+
+    updated_at : Optional[datetime.datetime]
+        The date and time when the data source was last updated.
+
+    use_remote_query_agent : Optional[bool]
+        A Boolean value that indicates whether to allow or disallow your Tableau
+        Cloud site to use Tableau Bridge clients. Bridge allows you to maintain
+        data sources with live connections to supported on-premises data
+        sources. See Configure and Manage the Bridge Client Pool for more
+        information.
+
+    webpage_url : Optional[str]
+        The url of the datasource as displayed in browsers.
+    """
+
     class AskDataEnablement:
         Enabled = "Enabled"
         Disabled = "Disabled"
@@ -33,29 +144,36 @@ class DatasourceItem:
         )
 
     def __init__(self, project_id: Optional[str] = None, name: Optional[str] = None) -> None:
-        self._ask_data_enablement = None
-        self._certified = None
-        self._certification_note = None
-        self._connections = None
+        self._ask_data_enablement: Optional[str] = None
+        self._certified: Optional[bool] = None
+        self._certification_note: Optional[str] = None
+        self._connections: Optional[list[ConnectionItem]] = None
         self._content_url: Optional[str] = None
-        self._created_at = None
-        self._datasource_type = None
-        self._description = None
-        self._encrypt_extracts = None
-        self._has_extracts = None
+        self._created_at: Optional[datetime.datetime] = None
+        self._datasource_type: Optional[str] = None
+        self._description: Optional[str] = None
+        self._encrypt_extracts: Optional[bool] = None
+        self._has_extracts: Optional[bool] = None
         self._id: Optional[str] = None
         self._initial_tags: set = set()
         self._project_name: Optional[str] = None
         self._revisions = None
         self._size: Optional[int] = None
-        self._updated_at = None
-        self._use_remote_query_agent = None
-        self._webpage_url = None
-        self.description = None
-        self.name = name
+        self._updated_at: Optional[datetime.datetime] = None
+        self._use_remote_query_agent: Optional[bool] = None
+        self._webpage_url: Optional[str] = None
+        self.description: Optional[str] = None
+        self.name: Optional[str] = name
         self.owner_id: Optional[str] = None
-        self.project_id = project_id
+        self.project_id: Optional[str] = project_id
         self.tags: set[str] = set()
+        self._connected_workbooks_count: Optional[int] = None
+        self._favorites_total: Optional[int] = None
+        self._has_alert: Optional[bool] = None
+        self._is_published: Optional[bool] = None
+        self._server_name: Optional[str] = None
+        self._project: Optional[ProjectItem] = None
+        self._owner: Optional[UserItem] = None
 
         self._permissions = None
         self._data_quality_warnings = None
@@ -63,16 +181,16 @@ class DatasourceItem:
         return None
 
     @property
-    def ask_data_enablement(self) -> Optional[AskDataEnablement]:
+    def ask_data_enablement(self) -> Optional[str]:
         return self._ask_data_enablement
 
     @ask_data_enablement.setter
     @property_is_enum(AskDataEnablement)
-    def ask_data_enablement(self, value: Optional[AskDataEnablement]):
+    def ask_data_enablement(self, value: Optional[str]):
         self._ask_data_enablement = value
 
     @property
-    def connections(self) -> Optional[list[ConnectionItem]]:
+    def connections(self):
         if self._connections is None:
             error = "Datasource item must be populated with connections first."
             raise UnpopulatedPropertyError(error)
@@ -112,7 +230,7 @@ class DatasourceItem:
         self._certification_note = value
 
     @property
-    def encrypt_extracts(self):
+    def encrypt_extracts(self) -> Optional[bool]:
         return self._encrypt_extracts
 
     @encrypt_extracts.setter
@@ -156,7 +274,7 @@ class DatasourceItem:
         return self._description
 
     @description.setter
-    def description(self, value: str):
+    def description(self, value: Optional[str]):
         self._description = value
 
     @property
@@ -187,14 +305,42 @@ class DatasourceItem:
     def size(self) -> Optional[int]:
         return self._size
 
-    def _set_connections(self, connections):
+    @property
+    def connected_workbooks_count(self) -> Optional[int]:
+        return self._connected_workbooks_count
+
+    @property
+    def favorites_total(self) -> Optional[int]:
+        return self._favorites_total
+
+    @property
+    def has_alert(self) -> Optional[bool]:
+        return self._has_alert
+
+    @property
+    def is_published(self) -> Optional[bool]:
+        return self._is_published
+
+    @property
+    def server_name(self) -> Optional[str]:
+        return self._server_name
+
+    @property
+    def project(self) -> Optional[ProjectItem]:
+        return self._project
+
+    @property
+    def owner(self) -> Optional[UserItem]:
+        return self._owner
+
+    def _set_connections(self, connections) -> None:
         self._connections = connections
 
     def _set_permissions(self, permissions):
         self._permissions = permissions
 
-    def _set_data_quality_warnings(self, dqws):
-        self._data_quality_warnings = dqws
+    def _set_data_quality_warnings(self, dqw):
+        self._data_quality_warnings = dqw
 
     def _set_revisions(self, revisions):
         self._revisions = revisions
@@ -223,6 +369,13 @@ class DatasourceItem:
                 use_remote_query_agent,
                 webpage_url,
                 size,
+                connected_workbooks_count,
+                favorites_total,
+                has_alert,
+                is_published,
+                server_name,
+                project,
+                owner,
             ) = self._parse_element(datasource_xml, ns)
             self._set_values(
                 ask_data_enablement,
@@ -244,6 +397,13 @@ class DatasourceItem:
                 use_remote_query_agent,
                 webpage_url,
                 size,
+                connected_workbooks_count,
+                favorites_total,
+                has_alert,
+                is_published,
+                server_name,
+                project,
+                owner,
             )
         return self
 
@@ -268,6 +428,13 @@ class DatasourceItem:
         use_remote_query_agent,
         webpage_url,
         size,
+        connected_workbooks_count,
+        favorites_total,
+        has_alert,
+        is_published,
+        server_name,
+        project,
+        owner,
     ):
         if ask_data_enablement is not None:
             self._ask_data_enablement = ask_data_enablement
@@ -307,6 +474,20 @@ class DatasourceItem:
             self._webpage_url = webpage_url
         if size is not None:
             self._size = int(size)
+        if connected_workbooks_count is not None:
+            self._connected_workbooks_count = connected_workbooks_count
+        if favorites_total is not None:
+            self._favorites_total = favorites_total
+        if has_alert is not None:
+            self._has_alert = has_alert
+        if is_published is not None:
+            self._is_published = is_published
+        if server_name is not None:
+            self._server_name = server_name
+        if project is not None:
+            self._project = project
+        if owner is not None:
+            self._owner = owner
 
     @classmethod
     def from_response(cls, resp: str, ns: dict) -> list["DatasourceItem"]:
@@ -341,6 +522,11 @@ class DatasourceItem:
         use_remote_query_agent = datasource_xml.get("useRemoteQueryAgent", None)
         webpage_url = datasource_xml.get("webpageUrl", None)
         size = datasource_xml.get("size", None)
+        connected_workbooks_count = nullable_str_to_int(datasource_xml.get("connectedWorkbooksCount", None))
+        favorites_total = nullable_str_to_int(datasource_xml.get("favoritesTotal", None))
+        has_alert = nullable_str_to_bool(datasource_xml.get("hasAlert", None))
+        is_published = nullable_str_to_bool(datasource_xml.get("isPublished", None))
+        server_name = datasource_xml.get("serverName", None)
 
         tags = None
         tags_elem = datasource_xml.find(".//t:tags", namespaces=ns)
@@ -351,12 +537,14 @@ class DatasourceItem:
         project_name = None
         project_elem = datasource_xml.find(".//t:project", namespaces=ns)
         if project_elem is not None:
+            project = ProjectItem.from_xml(project_elem, ns)
             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=ns)
         if owner_elem is not None:
+            owner = UserItem.from_xml(owner_elem, ns)
             owner_id = owner_elem.get("id", None)
 
         ask_data_enablement = None
@@ -384,4 +572,11 @@ class DatasourceItem:
             use_remote_query_agent,
             webpage_url,
             size,
+            connected_workbooks_count,
+            favorites_total,
+            has_alert,
+            is_published,
+            server_name,
+            project,
+            owner,
         )

tableauserverclient-0.38/tableauserverclient/models/extract_item.py

@@ -0,0 +1,82 @@
+from typing import Optional, List
+from defusedxml.ElementTree import fromstring
+import xml.etree.ElementTree as ET
+
+
+class ExtractItem:
+    """
+    An extract refresh task item.
+
+    Attributes
+    ----------
+    id : str
+        The ID of the extract refresh task
+    priority : int
+        The priority of the task
+    type : str
+        The type of extract refresh (incremental or full)
+    workbook_id : str, optional
+        The ID of the workbook if this is a workbook extract
+    datasource_id : str, optional
+        The ID of the datasource if this is a datasource extract
+    """
+
+    def __init__(
+        self, priority: int, refresh_type: str, workbook_id: Optional[str] = None, datasource_id: Optional[str] = None
+    ):
+        self._id: Optional[str] = None
+        self._priority = priority
+        self._type = refresh_type
+        self._workbook_id = workbook_id
+        self._datasource_id = datasource_id
+
+    @property
+    def id(self) -> Optional[str]:
+        return self._id
+
+    @property
+    def priority(self) -> int:
+        return self._priority
+
+    @property
+    def type(self) -> str:
+        return self._type
+
+    @property
+    def workbook_id(self) -> Optional[str]:
+        return self._workbook_id
+
+    @property
+    def datasource_id(self) -> Optional[str]:
+        return self._datasource_id
+
+    @classmethod
+    def from_response(cls, resp: str, ns: dict) -> List["ExtractItem"]:
+        """Create ExtractItem objects from XML response."""
+        parsed_response = fromstring(resp)
+        return cls.from_xml_element(parsed_response, ns)
+
+    @classmethod
+    def from_xml_element(cls, parsed_response: ET.Element, ns: dict) -> List["ExtractItem"]:
+        """Create ExtractItem objects from XML element."""
+        all_extract_items = []
+        all_extract_xml = parsed_response.findall(".//t:extract", namespaces=ns)
+
+        for extract_xml in all_extract_xml:
+            extract_id = extract_xml.get("id", None)
+            priority = int(extract_xml.get("priority", 0))
+            refresh_type = extract_xml.get("type", "")
+
+            # Check for workbook or datasource
+            workbook_elem = extract_xml.find(".//t:workbook", namespaces=ns)
+            datasource_elem = extract_xml.find(".//t:datasource", namespaces=ns)
+
+            workbook_id = workbook_elem.get("id", None) if workbook_elem is not None else None
+            datasource_id = datasource_elem.get("id", None) if datasource_elem is not None else None
+
+            extract_item = cls(priority, refresh_type, workbook_id, datasource_id)
+            extract_item._id = extract_id
+
+            all_extract_items.append(extract_item)
+
+        return all_extract_items

{tableauserverclient-0.36 → tableauserverclient-0.38}/tableauserverclient/models/flow_item.py

@@ -146,8 +146,8 @@ class FlowItem:
     def _set_permissions(self, permissions):
         self._permissions = permissions
 
-    def _set_data_quality_warnings(self, dqws):
-        self._data_quality_warnings = dqws
+    def _set_data_quality_warnings(self, dqw):
+        self._data_quality_warnings = dqw
 
     def _parse_common_elements(self, flow_xml, ns):
         if not isinstance(flow_xml, ET.Element):

{tableauserverclient-0.36 → tableauserverclient-0.38}/tableauserverclient/models/group_item.py

@@ -44,6 +44,11 @@ class GroupItem:
         login to a site. When the mode is onSync, a license is granted for group
         members each time the domain is synced.
 
+    Attributes
+    ----------
+    user_count: Optional[int]
+        The number of users in the group.
+
     Examples
     --------
     >>> # Create a new group item
@@ -65,6 +70,7 @@ class GroupItem:
         self._users: Optional[Callable[..., "Pager"]] = None
         self.name: Optional[str] = name
         self.domain_name: Optional[str] = domain_name
+        self._user_count: Optional[int] = None
 
     def __repr__(self):
         return f"{self.__class__.__name__}({self.__dict__!r})"
@@ -118,6 +124,10 @@ class GroupItem:
     def _set_users(self, users: Callable[..., "Pager"]) -> None:
         self._users = users
 
+    @property
+    def user_count(self) -> Optional[int]:
+        return self._user_count
+
     @classmethod
     def from_response(cls, resp, ns) -> list["GroupItem"]:
         all_group_items = list()
@@ -127,6 +137,7 @@ class GroupItem:
             name = group_xml.get("name", None)
             group_item = cls(name)
             group_item._id = group_xml.get("id", None)
+            group_item._user_count = int(count) if (count := group_xml.get("userCount", None)) else None
 
             # Domain name is returned in a domain element for some calls
             domain_elem = group_xml.find(".//t:domain", namespaces=ns)