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

tableauserverclient/models/interval_item.py

@@ -2,6 +2,13 @@ from .property_decorators import property_is_valid_time, property_not_nullable
 
 
 class IntervalItem:
+    """
+    This class sets the frequency and start time of the scheduled item. This
+    class contains the classes for the hourly, daily, weekly, and monthly
+    intervals. This class mirrors the options you can set using the REST API and
+    the Tableau Server interface.
+    """
+
     class Frequency:
         Hourly = "Hourly"
         Daily = "Daily"
@@ -26,6 +33,19 @@ class IntervalItem:
 
 
 class HourlyInterval:
+    """
+    Runs scheduled item hourly. To set the hourly interval, you create an
+    instance of the HourlyInterval class and assign the following values:
+    start_time, end_time, and interval_value. To set the start_time and
+    end_time, assign the time value using this syntax: start_time=time(hour, minute)
+    and end_time=time(hour, minute). The hour is specified in 24 hour time.
+    The interval_value specifies how often the to run the task within the
+    start and end time. The options are expressed in hours. For example,
+    interval_value=.25 is every 15 minutes. The values are .25, .5, 1, 2, 4, 6,
+    8, 12. Hourly schedules that run more frequently than every 60 minutes must
+    have start and end times that are on the hour.
+    """
+
     def __init__(self, start_time, end_time, interval_value):
         self.start_time = start_time
         self.end_time = end_time
@@ -109,6 +129,12 @@ class HourlyInterval:
 
 
 class DailyInterval:
+    """
+    Runs the scheduled item daily. To set the daily interval, you create an
+    instance of the DailyInterval and assign the start_time. The start time uses
+    the syntax start_time=time(hour, minute).
+    """
+
     def __init__(self, start_time, *interval_values):
         self.start_time = start_time
         self.interval = interval_values
@@ -177,6 +203,15 @@ class DailyInterval:
 
 
 class WeeklyInterval:
+    """
+    Runs the scheduled item once a week. To set the weekly interval, you create
+    an instance of the WeeklyInterval and assign the start time and multiple
+    instances for the interval_value (days of week and start time). The start
+    time uses the syntax time(hour, minute). The interval_value is the day of
+    the week, expressed as a IntervalItem. For example
+    TSC.IntervalItem.Day.Monday for Monday.
+    """
+
     def __init__(self, start_time, *interval_values):
         self.start_time = start_time
         self.interval = interval_values
@@ -214,6 +249,11 @@ class WeeklyInterval:
 
 
 class MonthlyInterval:
+    """
+    Runs the scheduled item once a month. To set the monthly interval, you
+    create an instance of the MonthlyInterval and assign the start time and day.
+    """
+
     def __init__(self, start_time, interval_value):
         self.start_time = start_time
 

tableauserverclient/models/job_item.py

@@ -82,6 +82,7 @@ class JobItem:
         Success: int = 0
         Failed: int = 1
         Cancelled: int = 2
+        Completed: int = 3
 
     def __init__(
         self,

tableauserverclient/models/location_item.py

@@ -0,0 +1,53 @@
+from typing import Optional
+import xml.etree.ElementTree as ET
+
+
+class LocationItem:
+    """
+    Details of where an item is located, such as a personal space or project.
+
+    Attributes
+    ----------
+    id : str | None
+        The ID of the location.
+
+    type : str | None
+        The type of location, such as PersonalSpace or Project.
+
+    name : str | None
+        The name of the location.
+    """
+
+    class Type:
+        PersonalSpace = "PersonalSpace"
+        Project = "Project"
+
+    def __init__(self):
+        self._id: Optional[str] = None
+        self._type: Optional[str] = None
+        self._name: Optional[str] = None
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self.__dict__!r})"
+
+    @property
+    def id(self) -> Optional[str]:
+        return self._id
+
+    @property
+    def type(self) -> Optional[str]:
+        return self._type
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @classmethod
+    def from_xml(cls, xml: ET.Element, ns: Optional[dict] = None) -> "LocationItem":
+        if ns is None:
+            ns = {}
+        location = cls()
+        location._id = xml.get("id", None)
+        location._type = xml.get("type", None)
+        location._name = xml.get("name", None)
+        return location

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: