tableauserverclient 0.33__py3-none-any.whl → 0.35__py3-none-any.whl

tableauserverclient/models/tag_item.py

@@ -1,16 +1,15 @@
 import xml.etree.ElementTree as ET
-from typing import Set
 
 from defusedxml.ElementTree import fromstring
 
 
-class TagItem(object):
+class TagItem:
     @classmethod
-    def from_response(cls, resp: bytes, ns) -> Set[str]:
+    def from_response(cls, resp: bytes, ns) -> set[str]:
         return cls.from_xml_element(fromstring(resp), ns)
 
     @classmethod
-    def from_xml_element(cls, parsed_response: ET.Element, ns) -> Set[str]:
+    def from_xml_element(cls, parsed_response: ET.Element, ns) -> set[str]:
         all_tags = set()
         tag_elem = parsed_response.findall(".//t:tag", namespaces=ns)
         for tag_xml in tag_elem:

tableauserverclient/models/task_item.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import List, Optional
+from typing import Optional
 
 from defusedxml.ElementTree import fromstring
 
@@ -8,7 +8,37 @@ from tableauserverclient.models.schedule_item import ScheduleItem
 from tableauserverclient.models.target import Target
 
 
-class TaskItem(object):
+class TaskItem:
+    """
+    Represents a task item in Tableau Server. To create new tasks, see Schedules.
+
+    Parameters
+    ----------
+    id_ : str
+        The ID of the task.
+
+    task_type : str
+        Type of task. See TaskItem.Type for possible values.
+
+    priority : int
+        The priority of the task on the server.
+
+    consecutive_failed_count : int
+        The number of consecutive times the task has failed.
+
+    schedule_id : str, optional
+        The ID of the schedule that the task is associated with.
+
+    schedule_item : ScheduleItem, optional
+        The schedule item that the task is associated with.
+
+    last_run_at : datetime, optional
+        The last time the task was run.
+
+    target : Target, optional
+        The target of the task. This can be a workbook or a datasource.
+    """
+
     class Type:
         ExtractRefresh = "extractRefresh"
         DataAcceleration = "dataAcceleration"
@@ -48,9 +78,9 @@ class TaskItem(object):
         )
 
     @classmethod
-    def from_response(cls, xml, ns, task_type=Type.ExtractRefresh) -> List["TaskItem"]:
+    def from_response(cls, xml, ns, task_type=Type.ExtractRefresh) -> list["TaskItem"]:
         parsed_response = fromstring(xml)
-        all_tasks_xml = parsed_response.findall(".//t:task/t:{}".format(task_type), namespaces=ns)
+        all_tasks_xml = parsed_response.findall(f".//t:task/t:{task_type}", namespaces=ns)
 
         all_tasks = (TaskItem._parse_element(x, ns) for x in all_tasks_xml)
 

tableauserverclient/models/user_item.py

@@ -2,7 +2,7 @@ import io
 import xml.etree.ElementTree as ET
 from datetime import datetime
 from enum import IntEnum
-from typing import Dict, List, Optional, TYPE_CHECKING, Tuple
+from typing import Optional, TYPE_CHECKING
 
 from defusedxml.ElementTree import fromstring
 
@@ -18,10 +18,35 @@ if TYPE_CHECKING:
     from tableauserverclient.server import Pager
 
 
-class UserItem(object):
+class UserItem:
+    """
+    The UserItem class contains the members or attributes for the view
+    resources on Tableau Server. The UserItem class defines the information you
+    can request or query from Tableau Server. The class attributes correspond
+    to the attributes of a server request or response payload.
+
+
+    Parameters
+    ----------
+    name: str
+        The name of the user.
+
+    site_role: str
+        The role of the user on the site.
+
+    auth_setting: str
+        Required attribute for Tableau Cloud. How the user autenticates to the
+        server.
+    """
+
     tag_name: str = "user"
 
     class Roles:
+        """
+        The Roles class contains the possible roles for a user on Tableau
+        Server.
+        """
+
         Interactor = "Interactor"
         Publisher = "Publisher"
         ServerAdministrator = "ServerAdministrator"
@@ -43,6 +68,11 @@ class UserItem(object):
         SupportUser = "SupportUser"
 
     class Auth:
+        """
+        The Auth class contains the possible authentication settings for a user
+        on Tableau Cloud.
+        """
+
         OpenID = "OpenID"
         SAML = "SAML"
         TableauIDWithMFA = "TableauIDWithMFA"
@@ -57,7 +87,7 @@ class UserItem(object):
         self._id: Optional[str] = None
         self._last_login: Optional[datetime] = None
         self._workbooks = None
-        self._favorites: Optional[Dict[str, List]] = None
+        self._favorites: Optional[dict[str, list]] = None
         self._groups = None
         self.email: Optional[str] = None
         self.fullname: Optional[str] = None
@@ -69,7 +99,7 @@ class UserItem(object):
 
     def __str__(self) -> str:
         str_site_role = self.site_role or "None"
-        return "<User {} name={} role={}>".format(self.id, self.name, str_site_role)
+        return f"<User {self.id} name={self.name} role={str_site_role}>"
 
     def __repr__(self):
         return self.__str__() + "  { " + ", ".join(" % s: % s" % item for item in vars(self).items()) + "}"
@@ -141,7 +171,7 @@ class UserItem(object):
         return self._workbooks()
 
     @property
-    def favorites(self) -> Dict[str, List]:
+    def favorites(self) -> dict[str, list]:
         if self._favorites is None:
             error = "User item must be populated with favorites first."
             raise UnpopulatedPropertyError(error)
@@ -210,12 +240,12 @@ class UserItem(object):
             self._domain_name = domain_name
 
     @classmethod
-    def from_response(cls, resp, ns) -> List["UserItem"]:
+    def from_response(cls, resp, ns) -> list["UserItem"]:
         element_name = ".//t:user"
         return cls._parse_xml(element_name, resp, ns)
 
     @classmethod
-    def from_response_as_owner(cls, resp, ns) -> List["UserItem"]:
+    def from_response_as_owner(cls, resp, ns) -> list["UserItem"]:
         element_name = ".//t:owner"
         return cls._parse_xml(element_name, resp, ns)
 
@@ -283,7 +313,7 @@ class UserItem(object):
             domain_name,
         )
 
-    class CSVImport(object):
+    class CSVImport:
         """
         This class includes hardcoded options and logic for the CSV file format defined for user import
         https://help.tableau.com/current/server/en-us/users_import.htm
@@ -308,7 +338,7 @@ class UserItem(object):
             if line is None or line is False or line == "\n" or line == "":
                 return None
             line = line.strip().lower()
-            values: List[str] = list(map(str.strip, line.split(",")))
+            values: list[str] = list(map(str.strip, line.split(",")))
             user = UserItem(values[UserItem.CSVImport.ColumnType.USERNAME])
             if len(values) > 1:
                 if len(values) > UserItem.CSVImport.ColumnType.MAX:
@@ -337,7 +367,7 @@ class UserItem(object):
         # Read through an entire CSV file meant for user import
         # Return the number of valid lines and a list of all the invalid lines
         @staticmethod
-        def validate_file_for_import(csv_file: io.TextIOWrapper, logger) -> Tuple[int, List[str]]:
+        def validate_file_for_import(csv_file: io.TextIOWrapper, logger) -> tuple[int, list[str]]:
             num_valid_lines = 0
             invalid_lines = []
             csv_file.seek(0)  # set to start of file in case it has been read earlier
@@ -345,11 +375,11 @@ class UserItem(object):
             while line and line != "":
                 try:
                     # do not print passwords
-                    logger.info("Reading user {}".format(line[:4]))
+                    logger.info(f"Reading user {line[:4]}")
                     UserItem.CSVImport._validate_import_line_or_throw(line, logger)
                     num_valid_lines += 1
                 except Exception as exc:
-                    logger.info("Error parsing {}: {}".format(line[:4], exc))
+                    logger.info(f"Error parsing {line[:4]}: {exc}")
                     invalid_lines.append(line)
                 line = csv_file.readline()
             return num_valid_lines, invalid_lines
@@ -358,7 +388,7 @@ class UserItem(object):
         # Iterate through each field and validate the given value against hardcoded constraints
         @staticmethod
         def _validate_import_line_or_throw(incoming, logger) -> None:
-            _valid_attributes: List[List[str]] = [
+            _valid_attributes: list[list[str]] = [
                 [],
                 [],
                 [],
@@ -373,23 +403,23 @@ class UserItem(object):
             if len(line) > UserItem.CSVImport.ColumnType.MAX:
                 raise AttributeError("Too many attributes in line")
             username = line[UserItem.CSVImport.ColumnType.USERNAME.value]
-            logger.debug("> details - {}".format(username))
+            logger.debug(f"> details - {username}")
             UserItem.validate_username_or_throw(username)
             for i in range(1, len(line)):
-                logger.debug("column {}: {}".format(UserItem.CSVImport.ColumnType(i).name, line[i]))
+                logger.debug(f"column {UserItem.CSVImport.ColumnType(i).name}: {line[i]}")
                 UserItem.CSVImport._validate_attribute_value(
                     line[i], _valid_attributes[i], UserItem.CSVImport.ColumnType(i)
                 )
 
         # Given a restricted set of possible values, confirm the item is in that set
         @staticmethod
-        def _validate_attribute_value(item: str, possible_values: List[str], column_type) -> None:
+        def _validate_attribute_value(item: str, possible_values: list[str], column_type) -> None:
             if item is None or item == "":
                 # value can be empty for any column except user, which is checked elsewhere
                 return
             if item in possible_values or possible_values == []:
                 return
-            raise AttributeError("Invalid value {} for {}".format(item, column_type))
+            raise AttributeError(f"Invalid value {item} for {column_type}")
 
         # https://help.tableau.com/current/server/en-us/csvguidelines.htm#settings_and_site_roles
         # This logic is hardcoded to match the existing rules for import csv files

tableauserverclient/models/view_item.py

@@ -1,23 +1,76 @@
 import copy
 from datetime import datetime
 from requests import Response
-from typing import Callable, Iterator, List, Optional, Set
+from typing import Callable, Optional
+from collections.abc import Iterator
 
 from defusedxml.ElementTree import fromstring
 
 from tableauserverclient.datetime_helpers import parse_datetime
-from .exceptions import UnpopulatedPropertyError
-from .permissions_item import PermissionsRule
-from .tag_item import TagItem
+from tableauserverclient.models.exceptions import UnpopulatedPropertyError
+from tableauserverclient.models.permissions_item import PermissionsRule
+from tableauserverclient.models.tag_item import TagItem
 
 
-class ViewItem(object):
+class ViewItem:
+    """
+    Contains the members or attributes for the view resources on Tableau Server.
+    The ViewItem class defines the information you can request or query from
+    Tableau Server. The class members correspond to the attributes of a server
+    request or response payload.
+
+    Attributes
+    ----------
+    content_url: Optional[str], default None
+        The name of the view as it would appear in a URL.
+
+    created_at: Optional[datetime], default None
+        The date and time when the view was created.
+
+    id: Optional[str], default None
+        The unique identifier for the view.
+
+    image: Optional[Callable[[], bytes]], default None
+        The image of the view. You must first call the `views.populate_image`
+        method to access the image.
+
+    name: Optional[str], default None
+        The name of the view.
+
+    owner_id: Optional[str], default None
+        The ID for the owner of the view.
+
+    pdf: Optional[Callable[[], bytes]], default None
+        The PDF of the view. You must first call the `views.populate_pdf`
+        method to access the PDF.
+
+    preview_image: Optional[Callable[[], bytes]], default None
+        The preview image of the view. You must first call the
+        `views.populate_preview_image` method to access the preview image.
+
+    project_id: Optional[str], default None
+        The ID for the project that contains the view.
+
+    tags: set[str], default set()
+        The tags associated with the view.
+
+    total_views: Optional[int], default None
+        The total number of views for the view.
+
+    updated_at: Optional[datetime], default None
+        The date and time when the view was last updated.
+
+    workbook_id: Optional[str], default None
+        The ID for the workbook that contains the view.
+
+    """
+
     def __init__(self) -> None:
         self._content_url: Optional[str] = None
         self._created_at: Optional[datetime] = None
         self._id: Optional[str] = None
         self._image: Optional[Callable[[], bytes]] = None
-        self._initial_tags: Set[str] = set()
+        self._initial_tags: set[str] = set()
         self._name: Optional[str] = None
         self._owner_id: Optional[str] = None
         self._preview_image: Optional[Callable[[], bytes]] = None
@@ -29,15 +82,15 @@ class ViewItem(object):
         self._sheet_type: Optional[str] = None
         self._updated_at: Optional[datetime] = None
         self._workbook_id: Optional[str] = None
-        self._permissions: Optional[Callable[[], List[PermissionsRule]]] = None
-        self.tags: Set[str] = set()
+        self._permissions: Optional[Callable[[], list[PermissionsRule]]] = None
+        self.tags: set[str] = set()
         self._data_acceleration_config = {
             "acceleration_enabled": None,
             "acceleration_status": None,
         }
 
     def __str__(self):
-        return "<ViewItem {0} '{1}' contentUrl='{2}' project={3}>".format(
+        return "<ViewItem {} '{}' contentUrl='{}' project={}>".format(
             self._id, self.name, self.content_url, self.project_id
         )
 
@@ -146,21 +199,21 @@ class ViewItem(object):
         self._data_acceleration_config = value
 
     @property
-    def permissions(self) -> List[PermissionsRule]:
+    def permissions(self) -> list[PermissionsRule]:
         if self._permissions is None:
             error = "View item must be populated with permissions first."
             raise UnpopulatedPropertyError(error)
         return self._permissions()
 
-    def _set_permissions(self, permissions: Callable[[], List[PermissionsRule]]) -> None:
+    def _set_permissions(self, permissions: Callable[[], list[PermissionsRule]]) -> None:
         self._permissions = permissions
 
     @classmethod
-    def from_response(cls, resp: "Response", ns, workbook_id="") -> List["ViewItem"]:
+    def from_response(cls, resp: "Response", ns, workbook_id="") -> list["ViewItem"]:
         return cls.from_xml_element(fromstring(resp), ns, workbook_id)
 
     @classmethod
-    def from_xml_element(cls, parsed_response, ns, workbook_id="") -> List["ViewItem"]:
+    def from_xml_element(cls, parsed_response, ns, workbook_id="") -> list["ViewItem"]:
         all_view_items = list()
         all_view_xml = parsed_response.findall(".//t:view", namespaces=ns)
         for view_xml in all_view_xml:

tableauserverclient/models/virtual_connection_item.py

@@ -1,6 +1,7 @@
 import datetime as dt
 import json
-from typing import Callable, Dict, Iterable, List, Optional
+from typing import Callable, Optional
+from collections.abc import Iterable
 from xml.etree.ElementTree import Element
 
 from defusedxml.ElementTree import fromstring
@@ -23,7 +24,7 @@ class VirtualConnectionItem:
         self._connections: Optional[Callable[[], Iterable[ConnectionItem]]] = None
         self.project_id: Optional[str] = None
         self.owner_id: Optional[str] = None
-        self.content: Optional[Dict[str, dict]] = None
+        self.content: Optional[dict[str, dict]] = None
         self.certification_note: Optional[str] = None
 
     def __str__(self) -> str:
@@ -40,7 +41,7 @@ class VirtualConnectionItem:
         return self._id
 
     @property
-    def permissions(self) -> List[PermissionsRule]:
+    def permissions(self) -> list[PermissionsRule]:
         if self._permissions is None:
             error = "Workbook item must be populated with permissions first."
             raise UnpopulatedPropertyError(error)
@@ -53,12 +54,12 @@ class VirtualConnectionItem:
         return self._connections()
 
     @classmethod
-    def from_response(cls, response: bytes, ns: Dict[str, str]) -> List["VirtualConnectionItem"]:
+    def from_response(cls, response: bytes, ns: dict[str, str]) -> list["VirtualConnectionItem"]:
         parsed_response = fromstring(response)
         return [cls.from_xml(xml, ns) for xml in parsed_response.findall(".//t:virtualConnection[@name]", ns)]
 
     @classmethod
-    def from_xml(cls, xml: Element, ns: Dict[str, str]) -> "VirtualConnectionItem":
+    def from_xml(cls, xml: Element, ns: dict[str, str]) -> "VirtualConnectionItem":
         v_conn = cls(xml.get("name", ""))
         v_conn._id = xml.get("id", None)
         v_conn.webpage_url = xml.get("webpageUrl", None)

tableauserverclient/models/webhook_item.py

@@ -1,6 +1,6 @@
 import re
 import xml.etree.ElementTree as ET
-from typing import List, Optional, Tuple, Type
+from typing import Optional
 
 from defusedxml.ElementTree import fromstring
 
@@ -13,7 +13,40 @@ def _parse_event(events):
     return NAMESPACE_RE.sub("", event.tag)
 
 
-class WebhookItem(object):
+class WebhookItem:
+    """
+    The WebhookItem represents the webhook resources on Tableau Server or
+    Tableau Cloud. This is the information that can be sent or returned in
+    response to a REST API request for webhooks.
+
+    Attributes
+    ----------
+    id : Optional[str]
+        The identifier (luid) for the webhook. You need this value to query a
+        specific webhook with the get_by_id method or to delete a webhook with
+        the delete method.
+
+    name : Optional[str]
+        The name of the webhook. You must specify this when you create an
+        instance of the WebhookItem.
+
+    url : Optional[str]
+        The destination URL for the webhook. The webhook destination URL must
+        be https and have a valid certificate. You must specify this when you
+        create an instance of the WebhookItem.
+
+    event : Optional[str]
+        The name of the Tableau event that triggers your webhook.This is either
+        api-event-name or webhook-source-api-event-name: one of these is
+        required to create an instance of the WebhookItem. We recommend using
+        the api-event-name. The event name must be one of the supported events
+        listed in the Trigger Events table.
+        https://help.tableau.com/current/developer/webhooks/en-us/docs/webhooks-events-payload.html
+
+    owner_id : Optional[str]
+        The identifier (luid) of the user who owns the webhook.
+    """
+
     def __init__(self):
         self._id: Optional[str] = None
         self.name: Optional[str] = None
@@ -45,10 +78,10 @@ class WebhookItem(object):
 
     @event.setter
     def event(self, value: str) -> None:
-        self._event = "webhook-source-event-{}".format(value)
+        self._event = f"webhook-source-event-{value}"
 
     @classmethod
-    def from_response(cls: Type["WebhookItem"], resp: bytes, ns) -> List["WebhookItem"]:
+    def from_response(cls: type["WebhookItem"], resp: bytes, ns) -> list["WebhookItem"]:
         all_webhooks_items = list()
         parsed_response = fromstring(resp)
         all_webhooks_xml = parsed_response.findall(".//t:webhook", namespaces=ns)
@@ -61,7 +94,7 @@ class WebhookItem(object):
         return all_webhooks_items
 
     @staticmethod
-    def _parse_element(webhook_xml: ET.Element, ns) -> Tuple:
+    def _parse_element(webhook_xml: ET.Element, ns) -> tuple:
         id = webhook_xml.get("id", None)
         name = webhook_xml.get("name", None)
 
@@ -82,4 +115,4 @@ class WebhookItem(object):
         return id, name, url, event, owner_id
 
     def __repr__(self) -> str:
-        return "<Webhook id={} name={} url={} event={}>".format(self.id, self.name, self.url, self.event)
+        return f"<Webhook id={self.id} name={self.name} url={self.url} event={self.event}>"