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

tableauserverclient/models/fileupload_item.py

@@ -1,7 +1,7 @@
 from defusedxml.ElementTree import fromstring
 
 
-class FileuploadItem(object):
+class FileuploadItem:
     def __init__(self):
         self._file_size = None
         self._upload_session_id = None

tableauserverclient/models/flow_item.py

@@ -1,7 +1,7 @@
 import copy
 import datetime
 import xml.etree.ElementTree as ET
-from typing import List, Optional, Set
+from typing import Iterable, Optional
 
 from defusedxml.ElementTree import fromstring
 
@@ -14,9 +14,54 @@ from tableauserverclient.models.property_decorators import property_not_nullable
 from tableauserverclient.models.tag_item import TagItem
 
 
-class FlowItem(object):
+class FlowItem:
+    """
+    Represents a Tableau Flow item.
+
+    Parameters
+    ----------
+    project_id: str
+        The ID of the project that the flow belongs to.
+
+    name: Optional[str]
+        The name of the flow.
+
+    Attributes
+    ----------
+    connections: Iterable[ConnectionItem]
+        The connections associated with the flow. This property is not populated
+        by default and must be populated by calling the `populate_connections`
+        method.
+
+    created_at: Optional[datetime.datetime]
+        The date and time when the flow was created.
+
+    description: Optional[str]
+        The description of the flow.
+
+    dqws: Iterable[DQWItem]
+        The data quality warnings associated with the flow. This property is not
+        populated by default and must be populated by calling the `populate_dqws`
+        method.
+
+    id: Optional[str]
+        The ID of the flow.
+
+    name: Optional[str]
+        The name of the flow.
+
+    owner_id: Optional[str]
+        The ID of the user who owns the flow.
+
+    project_name: Optional[str]
+        The name of the project that the flow belongs to.
+
+    tags: set[str]
+        The tags associated with the flow.
+    """
+
     def __repr__(self):
-        return "<Flow {0} '{1}' ({2}) Project={3} createdAt={4}".format(
+        return "<Flow {} '{}' ({}) Project={} createdAt={}".format(
             self._id, self.name, self.description, self.project_id, self.created_at
         )
 
@@ -24,18 +69,18 @@ class FlowItem(object):
         self._webpage_url: Optional[str] = None
         self._created_at: Optional[datetime.datetime] = None
         self._id: Optional[str] = None
-        self._initial_tags: Set[str] = set()
+        self._initial_tags: set[str] = set()
         self._project_name: Optional[str] = None
         self._updated_at: Optional[datetime.datetime] = None
         self.name: Optional[str] = name
         self.owner_id: Optional[str] = None
         self.project_id: str = project_id
-        self.tags: Set[str] = set()
+        self.tags: set[str] = set()
         self.description: Optional[str] = None
 
-        self._connections: Optional[ConnectionItem] = None
-        self._permissions: Optional[Permission] = None
-        self._data_quality_warnings: Optional[DQWItem] = None
+        self._connections: Optional[Iterable[ConnectionItem]] = None
+        self._permissions: Optional[Iterable[Permission]] = None
+        self._data_quality_warnings: Optional[Iterable[DQWItem]] = None
 
     @property
     def connections(self):
@@ -170,7 +215,7 @@ class FlowItem(object):
             self.owner_id = owner_id
 
     @classmethod
-    def from_response(cls, resp, ns) -> List["FlowItem"]:
+    def from_response(cls, resp, ns) -> list["FlowItem"]:
         all_flow_items = list()
         parsed_response = fromstring(resp)
         all_flow_xml = parsed_response.findall(".//t:flow", namespaces=ns)

tableauserverclient/models/flow_run_item.py

@@ -1,13 +1,13 @@
 import itertools
 from datetime import datetime
-from typing import Dict, List, Optional, Type
+from typing import Optional
 
 from defusedxml.ElementTree import fromstring
 
 from tableauserverclient.datetime_helpers import parse_datetime
 
 
-class FlowRunItem(object):
+class FlowRunItem:
     def __init__(self) -> None:
         self._id: str = ""
         self._flow_id: Optional[str] = None
@@ -71,7 +71,7 @@ class FlowRunItem(object):
             self._background_job_id = background_job_id
 
     @classmethod
-    def from_response(cls: Type["FlowRunItem"], resp: bytes, ns: Optional[Dict]) -> List["FlowRunItem"]:
+    def from_response(cls: type["FlowRunItem"], resp: bytes, ns: Optional[dict]) -> list["FlowRunItem"]:
         all_flowrun_items = list()
         parsed_response = fromstring(resp)
         all_flowrun_xml = itertools.chain(

tableauserverclient/models/group_item.py

@@ -1,4 +1,4 @@
-from typing import Callable, List, Optional, TYPE_CHECKING
+from typing import Callable, Optional, TYPE_CHECKING
 
 from defusedxml.ElementTree import fromstring
 
@@ -11,7 +11,47 @@ if TYPE_CHECKING:
     from tableauserverclient.server import Pager
 
 
-class GroupItem(object):
+class GroupItem:
+    """
+    The GroupItem class contains the attributes for the group resources on
+    Tableau Server. The GroupItem 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.
+
+    Parameters
+    ----------
+    name: str
+        The name of the group.
+
+    domain_name: str
+        The name of the Active Directory domain ("local" if local authentication is used).
+
+    Properties
+    ----------
+    users: Pager[UserItem]
+        The users in the group. Must be populated with a call to `populate_users()`.
+
+    id: str
+        The unique identifier for the group.
+
+    minimum_site_role: str
+        The minimum site role for users in the group. Use the `UserItem.Roles` enum.
+        Users in the group cannot have their site role set lower than this value.
+
+    license_mode: str
+        The mode defining when to apply licenses for group members. When the
+        mode is onLogin, a license is granted for each group member when they
+        login to a site. When the mode is onSync, a license is granted for group
+        members each time the domain is synced.
+
+    Examples
+    --------
+    >>> # Create a new group item
+    >>>  newgroup = TSC.GroupItem('My Group')
+
+
+    """
+
     tag_name: str = "group"
 
     class LicenseMode:
@@ -27,7 +67,7 @@ class GroupItem(object):
         self.domain_name: Optional[str] = domain_name
 
     def __repr__(self):
-        return "{}({!r})".format(self.__class__.__name__, self.__dict__)
+        return f"{self.__class__.__name__}({self.__dict__!r})"
 
     @property
     def domain_name(self) -> Optional[str]:
@@ -79,7 +119,7 @@ class GroupItem(object):
         self._users = users
 
     @classmethod
-    def from_response(cls, resp, ns) -> List["GroupItem"]:
+    def from_response(cls, resp, ns) -> list["GroupItem"]:
         all_group_items = list()
         parsed_response = fromstring(resp)
         all_group_xml = parsed_response.findall(".//t:group", namespaces=ns)

tableauserverclient/models/groupset_item.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional
+from typing import Optional
 import xml.etree.ElementTree as ET
 
 from defusedxml.ElementTree import fromstring
@@ -13,7 +13,7 @@ class GroupSetItem:
     def __init__(self, name: Optional[str] = None) -> None:
         self.name = name
         self.id: Optional[str] = None
-        self.groups: List["GroupItem"] = []
+        self.groups: list["GroupItem"] = []
         self.group_count: int = 0
 
     def __str__(self) -> str:
@@ -25,13 +25,13 @@ class GroupSetItem:
         return self.__str__()
 
     @classmethod
-    def from_response(cls, response: bytes, ns: Dict[str, str]) -> List["GroupSetItem"]:
+    def from_response(cls, response: bytes, ns: dict[str, str]) -> list["GroupSetItem"]:
         parsed_response = fromstring(response)
         all_groupset_xml = parsed_response.findall(".//t:groupSet", namespaces=ns)
         return [cls.from_xml(xml, ns) for xml in all_groupset_xml]
 
     @classmethod
-    def from_xml(cls, groupset_xml: ET.Element, ns: Dict[str, str]) -> "GroupSetItem":
+    def from_xml(cls, groupset_xml: ET.Element, ns: dict[str, str]) -> "GroupSetItem":
         def get_group(group_xml: ET.Element) -> GroupItem:
             group_item = GroupItem()
             group_item._id = group_xml.get("id")

tableauserverclient/models/interval_item.py

@@ -1,7 +1,7 @@
 from .property_decorators import property_is_valid_time, property_not_nullable
 
 
-class IntervalItem(object):
+class IntervalItem:
     class Frequency:
         Hourly = "Hourly"
         Daily = "Daily"
@@ -25,7 +25,7 @@ class IntervalItem(object):
         LastDay = "LastDay"
 
 
-class HourlyInterval(object):
+class HourlyInterval:
     def __init__(self, start_time, end_time, interval_value):
         self.start_time = start_time
         self.end_time = end_time
@@ -73,12 +73,12 @@ class HourlyInterval(object):
         for interval in intervals:
             # if an hourly interval is a string, then it is a weekDay interval
             if isinstance(interval, str) and not interval.isnumeric() and not hasattr(IntervalItem.Day, interval):
-                error = "Invalid weekDay interval {}".format(interval)
+                error = f"Invalid weekDay interval {interval}"
                 raise ValueError(error)
 
             # if an hourly interval is a number, it is an hours or minutes interval
             if isinstance(interval, (int, float)) and float(interval) not in VALID_INTERVALS:
-                error = "Invalid interval {} not in {}".format(interval, str(VALID_INTERVALS))
+                error = f"Invalid interval {interval} not in {str(VALID_INTERVALS)}"
                 raise ValueError(error)
 
         self._interval = intervals
@@ -108,7 +108,7 @@ class HourlyInterval(object):
         return interval_type_pairs
 
 
-class DailyInterval(object):
+class DailyInterval:
     def __init__(self, start_time, *interval_values):
         self.start_time = start_time
         self.interval = interval_values
@@ -141,12 +141,12 @@ class DailyInterval(object):
         for interval in intervals:
             # if an hourly interval is a string, then it is a weekDay interval
             if isinstance(interval, str) and not interval.isnumeric() and not hasattr(IntervalItem.Day, interval):
-                error = "Invalid weekDay interval {}".format(interval)
+                error = f"Invalid weekDay interval {interval}"
                 raise ValueError(error)
 
             # if an hourly interval is a number, it is an hours or minutes interval
             if isinstance(interval, (int, float)) and float(interval) not in VALID_INTERVALS:
-                error = "Invalid interval {} not in {}".format(interval, str(VALID_INTERVALS))
+                error = f"Invalid interval {interval} not in {str(VALID_INTERVALS)}"
                 raise ValueError(error)
 
         self._interval = intervals
@@ -176,7 +176,7 @@ class DailyInterval(object):
         return interval_type_pairs
 
 
-class WeeklyInterval(object):
+class WeeklyInterval:
     def __init__(self, start_time, *interval_values):
         self.start_time = start_time
         self.interval = interval_values
@@ -213,7 +213,7 @@ class WeeklyInterval(object):
         return [(IntervalItem.Occurrence.WeekDay, day) for day in self.interval]
 
 
-class MonthlyInterval(object):
+class MonthlyInterval:
     def __init__(self, start_time, interval_value):
         self.start_time = start_time
 

tableauserverclient/models/job_item.py

@@ -1,5 +1,5 @@
 import datetime
-from typing import List, Optional
+from typing import Optional
 
 from defusedxml.ElementTree import fromstring
 
@@ -7,7 +7,72 @@ from tableauserverclient.datetime_helpers import parse_datetime
 from tableauserverclient.models.flow_run_item import FlowRunItem
 
 
-class JobItem(object):
+class JobItem:
+    """
+    Using the TSC library, you can get information about an asynchronous process
+    (or job) on the server. These jobs can be created when Tableau runs certain
+    tasks that could be long running, such as importing or synchronizing users
+    from Active Directory, or running an extract refresh. For example, the REST
+    API methods to create or update groups, to run an extract refresh task, or
+    to publish workbooks can take an asJob parameter (asJob-true) that creates a
+    background process (the job) to complete the call. Information about the
+    asynchronous job is returned from the method.
+
+    If you have the identifier of the job, you can use the TSC library to find
+    out the status of the asynchronous job.
+
+    The job properties are defined in the JobItem class. The class corresponds
+    to the properties for jobs you can access using the Tableau Server REST API.
+    The job methods are based upon the endpoints for jobs in the REST API and
+    operate on the JobItem class.
+
+    Parameters
+    ----------
+    id_ : str
+        The identifier of the job.
+
+    job_type : str
+        The type of job.
+
+    progress : str
+        The progress of the job.
+
+    created_at : datetime.datetime
+        The date and time the job was created.
+
+    started_at : Optional[datetime.datetime]
+        The date and time the job was started.
+
+    completed_at : Optional[datetime.datetime]
+        The date and time the job was completed.
+
+    finish_code : int
+        The finish code of the job. 0 for success, 1 for failure, 2 for cancelled.
+
+    notes : Optional[list[str]]
+        Contains detailed notes about the job.
+
+    mode : Optional[str]
+
+    workbook_id : Optional[str]
+        The identifier of the workbook associated with the job.
+
+    datasource_id : Optional[str]
+        The identifier of the datasource associated with the job.
+
+    flow_run : Optional[FlowRunItem]
+        The flow run associated with the job.
+
+    updated_at : Optional[datetime.datetime]
+        The date and time the job was last updated.
+
+    workbook_name : Optional[str]
+        The name of the workbook associated with the job.
+
+    datasource_name : Optional[str]
+        The name of the datasource associated with the job.
+    """
+
     class FinishCode:
         """
         Status codes as documented on
@@ -27,7 +92,7 @@ class JobItem(object):
         started_at: Optional[datetime.datetime] = None,
         completed_at: Optional[datetime.datetime] = None,
         finish_code: int = 0,
-        notes: Optional[List[str]] = None,
+        notes: Optional[list[str]] = None,
         mode: Optional[str] = None,
         workbook_id: Optional[str] = None,
         datasource_id: Optional[str] = None,
@@ -43,7 +108,7 @@ class JobItem(object):
         self._started_at = started_at
         self._completed_at = completed_at
         self._finish_code = finish_code
-        self._notes: List[str] = notes or []
+        self._notes: list[str] = notes or []
         self._mode = mode
         self._workbook_id = workbook_id
         self._datasource_id = datasource_id
@@ -81,7 +146,7 @@ class JobItem(object):
         return self._finish_code
 
     @property
-    def notes(self) -> List[str]:
+    def notes(self) -> list[str]:
         return self._notes
 
     @property
@@ -139,7 +204,7 @@ class JobItem(object):
         return self.__str__() + "  { " + ", ".join(" % s: % s" % item for item in vars(self).items()) + "}"
 
     @classmethod
-    def from_response(cls, xml, ns) -> List["JobItem"]:
+    def from_response(cls, xml, ns) -> list["JobItem"]:
         parsed_response = fromstring(xml)
         all_tasks_xml = parsed_response.findall(".//t:job", namespaces=ns)
 
@@ -191,7 +256,7 @@ class JobItem(object):
         )
 
 
-class BackgroundJobItem(object):
+class BackgroundJobItem:
     class Status:
         Pending: str = "Pending"
         InProgress: str = "InProgress"
@@ -270,7 +335,7 @@ class BackgroundJobItem(object):
         return self._priority
 
     @classmethod
-    def from_response(cls, xml, ns) -> List["BackgroundJobItem"]:
+    def from_response(cls, xml, ns) -> list["BackgroundJobItem"]:
         parsed_response = fromstring(xml)
         all_tasks_xml = parsed_response.findall(".//t:backgroundJob", namespaces=ns)
         return [cls._parse_element(x, ns) for x in all_tasks_xml]

tableauserverclient/models/linked_tasks_item.py

@@ -1,5 +1,5 @@
 import datetime as dt
-from typing import List, Optional
+from typing import Optional
 
 from defusedxml.ElementTree import fromstring
 
@@ -14,7 +14,7 @@ class LinkedTaskItem:
         self.schedule: Optional[ScheduleItem] = None
 
     @classmethod
-    def from_response(cls, resp: bytes, namespace) -> List["LinkedTaskItem"]:
+    def from_response(cls, resp: bytes, namespace) -> list["LinkedTaskItem"]:
         parsed_response = fromstring(resp)
         return [
             cls._parse_element(x, namespace)
@@ -35,10 +35,10 @@ class LinkedTaskStepItem:
         self.id: Optional[str] = None
         self.step_number: Optional[int] = None
         self.stop_downstream_on_failure: Optional[bool] = None
-        self.task_details: List[LinkedTaskFlowRunItem] = []
+        self.task_details: list[LinkedTaskFlowRunItem] = []
 
     @classmethod
-    def from_task_xml(cls, xml, namespace) -> List["LinkedTaskStepItem"]:
+    def from_task_xml(cls, xml, namespace) -> list["LinkedTaskStepItem"]:
         return [cls._parse_element(x, namespace) for x in xml.findall(".//t:linkedTaskSteps[@id]", namespace)]
 
     @classmethod
@@ -61,7 +61,7 @@ class LinkedTaskFlowRunItem:
         self.flow_name: Optional[str] = None
 
     @classmethod
-    def _parse_element(cls, xml, namespace) -> List["LinkedTaskFlowRunItem"]:
+    def _parse_element(cls, xml, namespace) -> list["LinkedTaskFlowRunItem"]:
         all_tasks = []
         for flow_run in xml.findall(".//t:flowRun[@id]", namespace):
             task = cls()

tableauserverclient/models/metric_item.py

@@ -1,6 +1,6 @@
 import xml.etree.ElementTree as ET
 from datetime import datetime
-from typing import List, Optional, Set
+from typing import Optional
 
 from tableauserverclient.datetime_helpers import parse_datetime
 from .property_decorators import property_is_boolean, property_is_datetime
@@ -8,7 +8,7 @@ from .tag_item import TagItem
 from .permissions_item import Permission
 
 
-class MetricItem(object):
+class MetricItem:
     def __init__(self, name: Optional[str] = None):
         self._id: Optional[str] = None
         self._name: Optional[str] = name
@@ -21,8 +21,8 @@ class MetricItem(object):
         self._project_name: Optional[str] = None
         self._owner_id: Optional[str] = None
         self._view_id: Optional[str] = None
-        self._initial_tags: Set[str] = set()
-        self.tags: Set[str] = set()
+        self._initial_tags: set[str] = set()
+        self.tags: set[str] = set()
         self._permissions: Optional[Permission] = None
 
     @property
@@ -126,7 +126,7 @@ class MetricItem(object):
         cls,
         resp: bytes,
         ns,
-    ) -> List["MetricItem"]:
+    ) -> list["MetricItem"]:
         all_metric_items = list()
         parsed_response = ET.fromstring(resp)
         all_metric_xml = parsed_response.findall(".//t:metric", namespaces=ns)

tableauserverclient/models/pagination_item.py

@@ -1,7 +1,7 @@
 from defusedxml.ElementTree import fromstring
 
 
-class PaginationItem(object):
+class PaginationItem:
     def __init__(self):
         self._page_number = None
         self._page_size = None

tableauserverclient/models/permissions_item.py

@@ -1,5 +1,5 @@
 import xml.etree.ElementTree as ET
-from typing import Dict, List, Optional
+from typing import Optional
 
 from defusedxml.ElementTree import fromstring
 
@@ -36,23 +36,25 @@ class Permission:
         ShareView = "ShareView"
         ViewComments = "ViewComments"
         ViewUnderlyingData = "ViewUnderlyingData"
+        VizqlDataApiAccess = "VizqlDataApiAccess"
         WebAuthoring = "WebAuthoring"
         Write = "Write"
         RunExplainData = "RunExplainData"
         CreateRefreshMetrics = "CreateRefreshMetrics"
         SaveAs = "SaveAs"
+        PulseMetricDefine = "PulseMetricDefine"
 
         def __repr__(self):
             return "<Enum Capability: AddComment | ChangeHierarchy | ChangePermission ... (17 more) >"
 
 
 class PermissionsRule:
-    def __init__(self, grantee: ResourceReference, capabilities: Dict[str, str]) -> None:
+    def __init__(self, grantee: ResourceReference, capabilities: dict[str, str]) -> None:
         self.grantee = grantee
         self.capabilities = capabilities
 
     def __repr__(self):
-        return "<PermissionsRule grantee={}, capabilities={}>".format(self.grantee, self.capabilities)
+        return f"<PermissionsRule grantee={self.grantee}, capabilities={self.capabilities}>"
 
     def __eq__(self, other: object) -> bool:
         if not hasattr(other, "grantee") or not hasattr(other, "capabilities"):
@@ -66,7 +68,7 @@ class PermissionsRule:
         if self.capabilities == other.capabilities:
             return self
 
-        capabilities = set((*self.capabilities.keys(), *other.capabilities.keys()))
+        capabilities = {*self.capabilities.keys(), *other.capabilities.keys()}
         new_capabilities = {}
         for capability in capabilities:
             if (self.capabilities.get(capability), other.capabilities.get(capability)) == (
@@ -86,7 +88,7 @@ class PermissionsRule:
         if self.capabilities == other.capabilities:
             return self
 
-        capabilities = set((*self.capabilities.keys(), *other.capabilities.keys()))
+        capabilities = {*self.capabilities.keys(), *other.capabilities.keys()}
         new_capabilities = {}
         for capability in capabilities:
             if Permission.Mode.Allow in (self.capabilities.get(capability), other.capabilities.get(capability)):
@@ -100,14 +102,14 @@ class PermissionsRule:
         return PermissionsRule(self.grantee, new_capabilities)
 
     @classmethod
-    def from_response(cls, resp, ns=None) -> List["PermissionsRule"]:
+    def from_response(cls, resp, ns=None) -> list["PermissionsRule"]:
         parsed_response = fromstring(resp)
 
         rules = []
         permissions_rules_list_xml = parsed_response.findall(".//t:granteeCapabilities", namespaces=ns)
 
         for grantee_capability_xml in permissions_rules_list_xml:
-            capability_dict: Dict[str, str] = {}
+            capability_dict: dict[str, str] = {}
 
             grantee = PermissionsRule._parse_grantee_element(grantee_capability_xml, ns)
 
@@ -116,7 +118,7 @@ class PermissionsRule:
                 mode = capability_xml.get("mode")
 
                 if name is None or mode is None:
-                    logger.error("Capability was not valid: {}".format(capability_xml))
+                    logger.error(f"Capability was not valid: {capability_xml}")
                     raise UnpopulatedPropertyError()
                 else:
                     capability_dict[name] = mode
@@ -127,7 +129,7 @@ class PermissionsRule:
         return rules
 
     @staticmethod
-    def _parse_grantee_element(grantee_capability_xml: ET.Element, ns: Optional[Dict[str, str]]) -> ResourceReference:
+    def _parse_grantee_element(grantee_capability_xml: ET.Element, ns: Optional[dict[str, str]]) -> ResourceReference:
         """Use Xpath magic and some string splitting to get the right object type from the xml"""
 
         # Get the first element in the tree with an 'id' attribute
@@ -146,6 +148,6 @@ class PermissionsRule:
         elif grantee_type == "groupSet":
             grantee = GroupSetItem.as_reference(grantee_id)
         else:
-            raise UnknownGranteeTypeError("No support for grantee type of {}".format(grantee_type))
+            raise UnknownGranteeTypeError(f"No support for grantee type of {grantee_type}")
 
         return grantee