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

tableauserverclient/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."
@@ -75,6 +95,8 @@ class ProjectItem:
         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 +109,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
@@ -176,25 +205,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 +264,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 +291,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/schedule_item.py

@@ -20,6 +20,63 @@ 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"

tableauserverclient/models/site_item.py

@@ -1188,6 +1188,34 @@ class SiteItem:
         )
 
 
+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
+
+
 # Used to convert string represented boolean to a boolean type
 def string_to_bool(s: str) -> bool:
     return s.lower() == "true"

tableauserverclient/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/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:

tableauserverclient/models/user_item.py

@@ -7,6 +7,7 @@ from typing import Optional, TYPE_CHECKING
 from defusedxml.ElementTree import fromstring
 
 from tableauserverclient.datetime_helpers import parse_datetime
+from tableauserverclient.models.site_item import SiteAuthConfiguration
 from .exceptions import UnpopulatedPropertyError
 from .property_decorators import (
     property_is_enum,
@@ -37,6 +38,49 @@ class UserItem:
     auth_setting: str
         Required attribute for Tableau Cloud. How the user autenticates to the
         server.
+
+    Attributes
+    ----------
+    domain_name: Optional[str]
+        The name of the Active Directory domain ("local" if local authentication
+        is used).
+
+    email: Optional[str]
+        The email address of the user.
+
+    external_auth_user_id: Optional[str]
+        The unique identifier for the user in the external authentication system.
+
+    id: Optional[str]
+        The unique identifier for the user.
+
+    favorites: dict[str, list]
+        The favorites of the user. Must be populated with a call to
+        `populate_favorites()`.
+
+    fullname: Optional[str]
+        The full name of the user.
+
+    groups: Pager
+        The groups the user belongs to. Must be populated with a call to
+        `populate_groups()`.
+
+    last_login: Optional[datetime]
+        The last time the user logged in.
+
+    locale: Optional[str]
+        The locale of the user.
+
+    language: Optional[str]
+        Language setting for the user.
+
+    idp_configuration_id: Optional[str]
+        The ID of the identity provider configuration.
+
+    workbooks: Pager
+        The workbooks owned by the user. Must be populated with a call to
+        `populate_workbooks()`.
+
     """
 
     tag_name: str = "user"
@@ -94,6 +138,9 @@ class UserItem:
         self.name: Optional[str] = name
         self.site_role: Optional[str] = site_role
         self.auth_setting: Optional[str] = auth_setting
+        self._locale: Optional[str] = None
+        self._language: Optional[str] = None
+        self._idp_configuration_id: Optional[str] = None
 
         return None
 
@@ -184,6 +231,26 @@ class UserItem:
             raise UnpopulatedPropertyError(error)
         return self._groups()
 
+    @property
+    def locale(self) -> Optional[str]:
+        return self._locale
+
+    @property
+    def language(self) -> Optional[str]:
+        return self._language
+
+    @property
+    def idp_configuration_id(self) -> Optional[str]:
+        """
+        IDP configuration id for the user. This is only available on Tableau
+        Cloud, 3.24 or later
+        """
+        return self._idp_configuration_id
+
+    @idp_configuration_id.setter
+    def idp_configuration_id(self, value: str) -> None:
+        self._idp_configuration_id = value
+
     def _set_workbooks(self, workbooks) -> None:
         self._workbooks = workbooks
 
@@ -204,8 +271,11 @@ class UserItem:
                 email,
                 auth_setting,
                 _,
+                _,
+                _,
+                _,
             ) = self._parse_element(user_xml, ns)
-            self._set_values(None, None, site_role, None, None, fullname, email, auth_setting, None)
+            self._set_values(None, None, site_role, None, None, fullname, email, auth_setting, None, None, None, None)
         return self
 
     def _set_values(
@@ -219,6 +289,9 @@ class UserItem:
         email,
         auth_setting,
         domain_name,
+        locale,
+        language,
+        idp_configuration_id,
     ):
         if id is not None:
             self._id = id
@@ -238,6 +311,12 @@ class UserItem:
             self._auth_setting = auth_setting
         if domain_name:
             self._domain_name = domain_name
+        if locale:
+            self._locale = locale
+        if language:
+            self._language = language
+        if idp_configuration_id:
+            self._idp_configuration_id = idp_configuration_id
 
     @classmethod
     def from_response(cls, resp, ns) -> list["UserItem"]:
@@ -249,6 +328,12 @@ class UserItem:
         element_name = ".//t:owner"
         return cls._parse_xml(element_name, resp, ns)
 
+    @classmethod
+    def from_xml(cls, xml: ET.Element, ns: Optional[dict] = None) -> "UserItem":
+        item = cls()
+        item._set_values(*cls._parse_element(xml, ns))
+        return item
+
     @classmethod
     def _parse_xml(cls, element_name, resp, ns):
         all_user_items = []
@@ -265,6 +350,9 @@ class UserItem:
                 email,
                 auth_setting,
                 domain_name,
+                locale,
+                language,
+                idp_configuration_id,
             ) = cls._parse_element(user_xml, ns)
             user_item = cls(name, site_role)
             user_item._set_values(
@@ -277,6 +365,9 @@ class UserItem:
                 email,
                 auth_setting,
                 domain_name,
+                locale,
+                language,
+                idp_configuration_id,
             )
             all_user_items.append(user_item)
         return all_user_items
@@ -295,6 +386,9 @@ class UserItem:
         fullname = user_xml.get("fullName", None)
         email = user_xml.get("email", None)
         auth_setting = user_xml.get("authSetting", None)
+        locale = user_xml.get("locale", None)
+        language = user_xml.get("language", None)
+        idp_configuration_id = user_xml.get("idpConfigurationId", None)
 
         domain_name = None
         domain_elem = user_xml.find(".//t:domain", namespaces=ns)
@@ -311,6 +405,9 @@ class UserItem:
             email,
             auth_setting,
             domain_name,
+            locale,
+            language,
+            idp_configuration_id,
         )
 
     class CSVImport:
@@ -361,6 +458,9 @@ class UserItem:
                     values[UserItem.CSVImport.ColumnType.EMAIL],
                     values[UserItem.CSVImport.ColumnType.AUTH],
                     None,
+                    None,
+                    None,
+                    None,
                 )
             return user