tableauserverclient 0.37__py3-none-any.whl → 0.39__py3-none-any.whl

{tableauserverclient/models → models}/project_item.py

@@ -1,11 +1,11 @@
-import logging
 import xml.etree.ElementTree as ET
-from typing import Optional
+from typing import Optional, overload
 
 from defusedxml.ElementTree import fromstring
 
 from tableauserverclient.models.exceptions import UnpopulatedPropertyError
-from tableauserverclient.models.property_decorators import property_is_enum, property_not_empty
+from tableauserverclient.models.property_decorators import property_is_enum
+from tableauserverclient.models.user_item import UserItem
 
 
 class ProjectItem:
@@ -39,12 +39,32 @@ class ProjectItem:
 
     Attributes
     ----------
+    datasource_count : int
+        The number of data sources in the project.
+
     id : str
         The unique identifier for the project.
 
+    owner: Optional[UserItem]
+        The UserItem owner of the project.
+
     owner_id : str
         The unique identifier for the UserItem owner of the project.
 
+    project_count : int
+        The number of projects in the project.
+
+    top_level_project : bool
+        True if the project is a top-level project.
+
+    view_count : int
+        The number of views in the project.
+
+    workbook_count : int
+        The number of workbooks in the project.
+
+    writeable : bool
+        True if the project is writeable.
     """
 
     ERROR_MSG = "Project item must be populated with permissions first."
@@ -66,15 +86,18 @@ class ProjectItem:
         content_permissions: Optional[str] = None,
         parent_id: Optional[str] = None,
         samples: Optional[bool] = None,
+        id: Optional[str] = None,
     ) -> None:
         self._content_permissions = None
-        self._id: Optional[str] = None
+        self._id: Optional[str] = id
         self.description: Optional[str] = description
         self.name: str = name
         self.content_permissions: Optional[str] = content_permissions
         self.parent_id: Optional[str] = parent_id
         self._samples: Optional[bool] = samples
         self._owner_id: Optional[str] = None
+        self._top_level_project: Optional[bool] = None
+        self._writeable: Optional[bool] = None
 
         self._permissions = None
         self._default_workbook_permissions = None
@@ -87,6 +110,13 @@ class ProjectItem:
         self._default_database_permissions = None
         self._default_table_permissions = None
 
+        self._project_count: Optional[int] = None
+        self._workbook_count: Optional[int] = None
+        self._view_count: Optional[int] = None
+        self._datasource_count: Optional[int] = None
+
+        self._owner: Optional[UserItem] = None
+
     @property
     def content_permissions(self):
         return self._content_permissions
@@ -165,7 +195,7 @@ class ProjectItem:
         return self._name
 
     @name.setter
-    def name(self, value: str) -> None:
+    def name(self, value: Optional[str]) -> None:
         self._name = value
 
     @property
@@ -176,25 +206,53 @@ class ProjectItem:
     def owner_id(self, value: str) -> None:
         self._owner_id = value
 
+    @property
+    def top_level_project(self) -> Optional[bool]:
+        return self._top_level_project
+
+    @property
+    def writeable(self) -> Optional[bool]:
+        return self._writeable
+
+    @property
+    def project_count(self) -> Optional[int]:
+        return self._project_count
+
+    @property
+    def workbook_count(self) -> Optional[int]:
+        return self._workbook_count
+
+    @property
+    def view_count(self) -> Optional[int]:
+        return self._view_count
+
+    @property
+    def datasource_count(self) -> Optional[int]:
+        return self._datasource_count
+
+    @property
+    def owner(self) -> Optional[UserItem]:
+        return self._owner
+
     def is_default(self):
         return self.name.lower() == "default"
 
-    def _parse_common_tags(self, project_xml, ns):
-        if not isinstance(project_xml, ET.Element):
-            project_xml = fromstring(project_xml).find(".//t:project", namespaces=ns)
-
-        if project_xml is not None:
-            (
-                _,
-                name,
-                description,
-                content_permissions,
-                parent_id,
-            ) = self._parse_element(project_xml)
-            self._set_values(None, name, description, content_permissions, parent_id)
-        return self
-
-    def _set_values(self, project_id, name, description, content_permissions, parent_id, owner_id):
+    def _set_values(
+        self,
+        project_id,
+        name,
+        description,
+        content_permissions,
+        parent_id,
+        owner_id,
+        top_level_project,
+        writeable,
+        project_count,
+        workbook_count,
+        view_count,
+        datasource_count,
+        owner,
+    ):
         if project_id is not None:
             self._id = project_id
         if name:
@@ -207,6 +265,20 @@ class ProjectItem:
             self.parent_id = parent_id
         if owner_id:
             self._owner_id = owner_id
+        if project_count is not None:
+            self._project_count = project_count
+        if workbook_count is not None:
+            self._workbook_count = workbook_count
+        if view_count is not None:
+            self._view_count = view_count
+        if datasource_count is not None:
+            self._datasource_count = datasource_count
+        if top_level_project is not None:
+            self._top_level_project = top_level_project
+        if writeable is not None:
+            self._writeable = writeable
+        if owner is not None:
+            self._owner = owner
 
     def _set_permissions(self, permissions):
         self._permissions = permissions
@@ -220,31 +292,71 @@ class ProjectItem:
         )
 
     @classmethod
-    def from_response(cls, resp, ns) -> list["ProjectItem"]:
+    def from_response(cls, resp: bytes, ns: Optional[dict]) -> list["ProjectItem"]:
         all_project_items = list()
         parsed_response = fromstring(resp)
         all_project_xml = parsed_response.findall(".//t:project", namespaces=ns)
 
         for project_xml in all_project_xml:
-            project_item = cls.from_xml(project_xml)
+            project_item = cls.from_xml(project_xml, namespace=ns)
             all_project_items.append(project_item)
         return all_project_items
 
     @classmethod
-    def from_xml(cls, project_xml, namespace=None) -> "ProjectItem":
+    def from_xml(cls, project_xml: ET.Element, namespace: Optional[dict] = None) -> "ProjectItem":
         project_item = cls()
-        project_item._set_values(*cls._parse_element(project_xml))
+        project_item._set_values(*cls._parse_element(project_xml, namespace))
         return project_item
 
     @staticmethod
-    def _parse_element(project_xml):
+    def _parse_element(project_xml: ET.Element, namespace: Optional[dict]) -> tuple:
         id = project_xml.get("id", None)
         name = project_xml.get("name", None)
         description = project_xml.get("description", None)
         content_permissions = project_xml.get("contentPermissions", None)
         parent_id = project_xml.get("parentProjectId", None)
+        top_level_project = str_to_bool(project_xml.get("topLevelProject", None))
+        writeable = str_to_bool(project_xml.get("writeable", None))
         owner_id = None
-        for owner in project_xml:
-            owner_id = owner.get("id", None)
+        owner = None
+        if (owner_elem := project_xml.find(".//t:owner", namespaces=namespace)) is not None:
+            owner = UserItem.from_xml(owner_elem, namespace)
+            owner_id = owner_elem.get("id", None)
+
+        project_count = None
+        workbook_count = None
+        view_count = None
+        datasource_count = None
+        if (count_elem := project_xml.find(".//t:contentsCounts", namespaces=namespace)) is not None:
+            project_count = int(count_elem.get("projectCount", 0))
+            workbook_count = int(count_elem.get("workbookCount", 0))
+            view_count = int(count_elem.get("viewCount", 0))
+            datasource_count = int(count_elem.get("dataSourceCount", 0))
+
+        return (
+            id,
+            name,
+            description,
+            content_permissions,
+            parent_id,
+            owner_id,
+            top_level_project,
+            writeable,
+            project_count,
+            workbook_count,
+            view_count,
+            datasource_count,
+            owner,
+        )
+
+
+@overload
+def str_to_bool(value: str) -> bool: ...
+
+
+@overload
+def str_to_bool(value: None) -> None: ...
+
 
-        return id, name, description, content_permissions, parent_id, owner_id
+def str_to_bool(value):
+    return value.lower() == "true" if value is not None else None

{tableauserverclient/models → models}/property_decorators.py

@@ -1,7 +1,7 @@
 import datetime
 import re
 from functools import wraps
-from typing import Any, Optional
+from typing import Any
 from collections.abc import Container
 
 from tableauserverclient.datetime_helpers import parse_datetime
@@ -67,7 +67,7 @@ def property_is_valid_time(func):
     return wrapper
 
 
-def property_is_int(range: tuple[int, int], allowed: Optional[Container[Any]] = None):
+def property_is_int(range: tuple[int, int], allowed: Container[Any] | None = None):
     """Takes a range of ints and a list of exemptions to check against
     when setting a property on a model. The range is a tuple of (min, max) and the
     allowed list (empty by default) allows values outside that range.

{tableauserverclient/models → models}/reference_item.py

@@ -1,9 +1,12 @@
+from typing_extensions import Self
+
+
 class ResourceReference:
-    def __init__(self, id_, tag_name):
+    def __init__(self, id_: str | None, tag_name: str) -> None:
         self.id = id_
         self.tag_name = tag_name
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"<ResourceReference id={self._id} tag={self._tag_name}>"
 
     __repr__ = __str__
@@ -13,18 +16,21 @@ class ResourceReference:
             return False
         return (self.id == other.id) and (self.tag_name == other.tag_name)
 
+    def __hash__(self: Self) -> int:
+        return hash((self.id, self.tag_name))
+
     @property
-    def id(self):
+    def id(self) -> str | None:
         return self._id
 
     @id.setter
-    def id(self, value):
+    def id(self, value: str | None) -> None:
         self._id = value
 
     @property
-    def tag_name(self):
+    def tag_name(self) -> str:
         return self._tag_name
 
     @tag_name.setter
-    def tag_name(self, value):
+    def tag_name(self, value: str) -> None:
         self._tag_name = value

{tableauserverclient/models → models}/schedule_item.py

@@ -1,6 +1,6 @@
 import xml.etree.ElementTree as ET
 from datetime import datetime
-from typing import Optional, Union
+from typing import Optional, Union, TYPE_CHECKING
 
 from defusedxml.ElementTree import fromstring
 
@@ -16,10 +16,71 @@ from .property_decorators import (
     property_is_enum,
 )
 
+if TYPE_CHECKING:
+    from requests import Response
+
+
 Interval = Union[HourlyInterval, DailyInterval, WeeklyInterval, MonthlyInterval]
 
 
 class ScheduleItem:
+    """
+    Using the TSC library, you can schedule extract refresh or subscription
+    tasks on Tableau Server. You can also get and update information about the
+    scheduled tasks, or delete scheduled tasks.
+
+    If you have the identifier of the job, you can use the TSC library to find
+    out the status of the asynchronous job.
+
+    The schedule properties are defined in the ScheduleItem class. The class
+    corresponds to the properties for schedules you can access in Tableau
+    Server or by using the Tableau Server REST API. The Schedule methods are
+    based upon the endpoints for jobs in the REST API and operate on the JobItem
+    class.
+
+    Parameters
+    ----------
+    name : str
+        The name of the schedule.
+
+    priority : int
+        The priority of the schedule. Lower values represent higher priority,
+        with 0 indicating the highest priority.
+
+    schedule_type : str
+        The type of task schedule. See ScheduleItem.Type for the possible values.
+
+    execution_order : str
+        Specifies how the scheduled tasks should run. The choices are Parallel
+        which uses all avaiable background processes for a scheduled task, or
+        Serial, which limits the schedule to one background process.
+
+    interval_item : Interval
+        Specifies the frequency that the scheduled task should run. The
+        interval_item is an instance of the IntervalItem class. The
+        interval_item has properties for frequency (hourly, daily, weekly,
+        monthly), and what time and date the scheduled item runs. You set this
+        value by declaring an IntervalItem object that is one of the following:
+        HourlyInterval, DailyInterval, WeeklyInterval, or MonthlyInterval.
+
+    Attributes
+    ----------
+    created_at : datetime
+        The date and time the schedule was created.
+
+    end_schedule_at : datetime
+        The date and time the schedule ends.
+
+    id : str
+        The unique identifier for the schedule.
+
+    next_run_at : datetime
+        The date and time the schedule is next run.
+
+    state : str
+        The state of the schedule. See ScheduleItem.State for the possible values.
+    """
+
     class Type:
         Extract = "Extract"
         Flow = "Flow"
@@ -350,3 +411,8 @@ class ScheduleItem:
         for warning_xml in all_warning_xml:
             warnings.append(warning_xml.get("message", None))
         return warnings
+
+
+def parse_batch_schedule_state(response: "Response", ns) -> list[str]:
+    xml = fromstring(response.content)
+    return [text for tag in xml.findall(".//t:scheduleLuid", namespaces=ns) if (text := tag.text)]

{tableauserverclient/models → models}/site_item.py

@@ -85,6 +85,9 @@ class SiteItem:
     state: str
         Shows the current state of the site (Active or Suspended).
 
+    attribute_capture_enabled: Optional[str]
+        Enables user attributes for all Tableau Server embedding workflows.
+
     """
 
     _user_quota: Optional[int] = None
@@ -164,6 +167,7 @@ class SiteItem:
         time_zone=None,
         auto_suspend_refresh_enabled: bool = True,
         auto_suspend_refresh_inactivity_window: int = 30,
+        attribute_capture_enabled: Optional[bool] = None,
     ):
         self._admin_mode = None
         self._id: Optional[str] = None
@@ -217,6 +221,7 @@ class SiteItem:
         self.time_zone = time_zone
         self.auto_suspend_refresh_enabled = auto_suspend_refresh_enabled
         self.auto_suspend_refresh_inactivity_window = auto_suspend_refresh_inactivity_window
+        self.attribute_capture_enabled = attribute_capture_enabled
 
     @property
     def admin_mode(self) -> Optional[str]:
@@ -720,6 +725,7 @@ class SiteItem:
                 time_zone,
                 auto_suspend_refresh_enabled,
                 auto_suspend_refresh_inactivity_window,
+                attribute_capture_enabled,
             ) = self._parse_element(site_xml, ns)
 
             self._set_values(
@@ -774,6 +780,7 @@ class SiteItem:
                 time_zone,
                 auto_suspend_refresh_enabled,
                 auto_suspend_refresh_inactivity_window,
+                attribute_capture_enabled,
             )
         return self
 
@@ -830,6 +837,7 @@ class SiteItem:
         time_zone,
         auto_suspend_refresh_enabled,
         auto_suspend_refresh_inactivity_window,
+        attribute_capture_enabled,
     ):
         if id is not None:
             self._id = id
@@ -937,6 +945,7 @@ class SiteItem:
             self.auto_suspend_refresh_enabled = auto_suspend_refresh_enabled
         if auto_suspend_refresh_inactivity_window is not None:
             self.auto_suspend_refresh_inactivity_window = auto_suspend_refresh_inactivity_window
+        self.attribute_capture_enabled = attribute_capture_enabled
 
     @classmethod
     def from_response(cls, resp, ns) -> list["SiteItem"]:
@@ -996,6 +1005,7 @@ class SiteItem:
                 time_zone,
                 auto_suspend_refresh_enabled,
                 auto_suspend_refresh_inactivity_window,
+                attribute_capture_enabled,
             ) = cls._parse_element(site_xml, ns)
 
             site_item = cls(name, content_url)
@@ -1051,6 +1061,7 @@ class SiteItem:
                 time_zone,
                 auto_suspend_refresh_enabled,
                 auto_suspend_refresh_inactivity_window,
+                attribute_capture_enabled,
             )
             all_site_items.append(site_item)
         return all_site_items
@@ -1132,6 +1143,9 @@ class SiteItem:
 
         flows_enabled = string_to_bool(site_xml.get("flowsEnabled", ""))
         cataloging_enabled = string_to_bool(site_xml.get("catalogingEnabled", ""))
+        attribute_capture_enabled = (
+            string_to_bool(ace) if (ace := site_xml.get("attributeCaptureEnabled")) is not None else None
+        )
 
         return (
             id,
@@ -1185,8 +1199,48 @@ class SiteItem:
             time_zone,
             auto_suspend_refresh_enabled,
             auto_suspend_refresh_inactivity_window,
+            attribute_capture_enabled,
+        )
+
+
+class SiteAuthConfiguration:
+    """
+    Authentication configuration for a site.
+    """
+
+    def __init__(self):
+        self.auth_setting: Optional[str] = None
+        self.enabled: Optional[bool] = None
+        self.idp_configuration_id: Optional[str] = None
+        self.idp_configuration_name: Optional[str] = None
+        self.known_provider_alias: Optional[str] = None
+
+    @classmethod
+    def from_response(cls, resp: bytes, ns: dict) -> list["SiteAuthConfiguration"]:
+        all_auth_configs = list()
+        parsed_response = fromstring(resp)
+        all_auth_xml = parsed_response.findall(".//t:siteAuthConfiguration", namespaces=ns)
+        for auth_xml in all_auth_xml:
+            auth_config = cls()
+            auth_config.auth_setting = auth_xml.get("authSetting", None)
+            auth_config.enabled = string_to_bool(auth_xml.get("enabled", ""))
+            auth_config.idp_configuration_id = auth_xml.get("idpConfigurationId", None)
+            auth_config.idp_configuration_name = auth_xml.get("idpConfigurationName", None)
+            auth_config.known_provider_alias = auth_xml.get("knownProviderAlias", None)
+            all_auth_configs.append(auth_config)
+        return all_auth_configs
+
+    def __str__(self):
+        return (
+            f"{self.__class__.__qualname__}(auth_setting={self.auth_setting}, "
+            f"enabled={self.enabled}, "
+            f"idp_configuration_id={self.idp_configuration_id}, "
+            f"idp_configuration_name={self.idp_configuration_name})"
         )
 
+    def __repr__(self):
+        return f"<{str(self)}>"
+
 
 # Used to convert string represented boolean to a boolean type
 def string_to_bool(s: str) -> bool:

{tableauserverclient/models → models}/table_item.py

@@ -1,8 +1,12 @@
+from typing import Callable, Optional, TYPE_CHECKING
 from defusedxml.ElementTree import fromstring
 
 from .exceptions import UnpopulatedPropertyError
 from .property_decorators import property_not_empty, property_is_boolean
 
+if TYPE_CHECKING:
+    from tableauserverclient.models import DQWItem
+
 
 class TableItem:
     def __init__(self, name, description=None):
@@ -40,7 +44,7 @@ class TableItem:
         return self._data_quality_warnings()
 
     @property
-    def id(self):
+    def id(self) -> Optional[str]:
         return self._id
 
     @property
@@ -100,8 +104,8 @@ class TableItem:
     def _set_columns(self, columns):
         self._columns = columns
 
-    def _set_data_quality_warnings(self, dqws):
-        self._data_quality_warnings = dqws
+    def _set_data_quality_warnings(self, dqw: Callable[[], list["DQWItem"]]) -> None:
+        self._data_quality_warnings = dqw
 
     def _set_values(self, table_values):
         if "id" in table_values:

{tableauserverclient/models → models}/tableau_auth.py

@@ -87,7 +87,7 @@ class TableauAuth(Credentials):
             uid = f", user_id_to_impersonate=f{self.user_id_to_impersonate}"
         else:
             uid = ""
-        return f"<Credentials username={self.username} password=redacted (site={self.site_id}{uid})>"
+        return f"<{self.__class__.__qualname__} username={self.username} password=redacted (site={self.site_id}{uid})>"
 
 
 # A Tableau-generated Personal Access Token
@@ -155,8 +155,8 @@ class PersonalAccessTokenAuth(Credentials):
         else:
             uid = ""
         return (
-            f"<PersonalAccessToken name={self.token_name} token={self.personal_access_token[:2]}..."
-            f"(site={self.site_id}{uid} >"
+            f"<{self.__class__.__qualname__}(name={self.token_name} token={self.personal_access_token[:2]}..."
+            f"site={self.site_id}{uid}) >"
         )
 
 
@@ -198,19 +198,26 @@ class JWTAuth(Credentials):
 
     """
 
-    def __init__(self, jwt: str, site_id: Optional[str] = None, user_id_to_impersonate: Optional[str] = None) -> None:
+    def __init__(
+        self,
+        jwt: str,
+        isUat: bool = False,
+        site_id: Optional[str] = None,
+        user_id_to_impersonate: Optional[str] = None,
+    ) -> None:
         if jwt is None:
             raise TabError("Must provide a JWT token when using JWT authentication")
         super().__init__(site_id, user_id_to_impersonate)
         self.jwt = jwt
+        self.isUat = isUat
 
     @property
     def credentials(self) -> dict[str, str]:
-        return {"jwt": self.jwt}
+        return {"jwt": self.jwt, "isUat": str(self.isUat).lower()}
 
     def __repr__(self):
         if self.user_id_to_impersonate:
             uid = f", user_id_to_impersonate=f{self.user_id_to_impersonate}"
         else:
             uid = ""
-        return f"<{self.__class__.__qualname__} jwt={self.jwt[:5]}... (site={self.site_id}{uid})>"
+        return f"<{self.__class__.__qualname__} jwt={self.jwt[:5]}... isUat={self.isUat} (site={self.site_id}{uid})>"

{tableauserverclient/models → models}/tableau_types.py

@@ -1,8 +1,10 @@
 from typing import Union
 
+from tableauserverclient.models.database_item import DatabaseItem
 from tableauserverclient.models.datasource_item import DatasourceItem
 from tableauserverclient.models.flow_item import FlowItem
 from tableauserverclient.models.project_item import ProjectItem
+from tableauserverclient.models.table_item import TableItem
 from tableauserverclient.models.view_item import ViewItem
 from tableauserverclient.models.workbook_item import WorkbookItem
 from tableauserverclient.models.metric_item import MetricItem
@@ -25,7 +27,17 @@ class Resource:
 
 # resource types that have permissions, can be renamed, etc
 # todo: refactoring: should actually define TableauItem as an interface and let all these implement it
-TableauItem = Union[DatasourceItem, FlowItem, MetricItem, ProjectItem, ViewItem, WorkbookItem, VirtualConnectionItem]
+TableauItem = Union[
+    DatasourceItem,
+    FlowItem,
+    MetricItem,
+    ProjectItem,
+    ViewItem,
+    WorkbookItem,
+    VirtualConnectionItem,
+    DatabaseItem,
+    TableItem,
+]
 
 
 def plural_type(content_type: Union[Resource, str]) -> str: