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

tableauserverclient/models/server_info_item.py

@@ -6,7 +6,29 @@ from defusedxml.ElementTree import fromstring
 from tableauserverclient.helpers.logging import logger
 
 
-class ServerInfoItem(object):
+class ServerInfoItem:
+    """
+    The ServerInfoItem class contains the build and version information for
+    Tableau Server. The server information is accessed with the
+    server_info.get() method, which returns an instance of the ServerInfo class.
+
+    Attributes
+    ----------
+    product_version : str
+        Shows the version of the Tableau Server or Tableau Cloud
+        (for example, 10.2.0).
+
+    build_number : str
+        Shows the specific build number (for example, 10200.17.0329.1446).
+
+    rest_api_version : str
+        Shows the supported REST API version number. Note that this might be
+        different from the default value specified for the server, with the
+        Server.version attribute. To take advantage of new features, you should
+        query the server and set the Server.version to match the supported REST
+        API version number.
+    """
+
     def __init__(self, product_version, build_number, rest_api_version):
         self._product_version = product_version
         self._build_number = build_number
@@ -40,13 +62,11 @@ class ServerInfoItem(object):
         try:
             parsed_response = fromstring(resp)
         except xml.etree.ElementTree.ParseError as error:
-            logger.info("Unexpected response for ServerInfo: {}".format(resp))
-            logger.info(error)
+            logger.exception(f"Unexpected response for ServerInfo: {resp}")
             return cls("Unknown", "Unknown", "Unknown")
         except Exception as error:
-            logger.info("Unexpected response for ServerInfo: {}".format(resp))
-            logger.info(error)
-            return cls("Unknown", "Unknown", "Unknown")
+            logger.exception(f"Unexpected response for ServerInfo: {resp}")
+            raise error
 
         product_version_tag = parsed_response.find(".//t:productVersion", namespaces=ns)
         rest_api_version_tag = parsed_response.find(".//t:restApiVersion", namespaces=ns)

tableauserverclient/models/site_item.py

@@ -14,13 +14,79 @@ from .property_decorators import (
 
 VALID_CONTENT_URL_RE = r"^[a-zA-Z0-9_\-]*$"
 
-from typing import List, Optional, Union, TYPE_CHECKING
+from typing import Optional, Union, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from tableauserverclient.server import Server
 
 
-class SiteItem(object):
+class SiteItem:
+    """
+    The SiteItem class contains the members or attributes for the site resources
+    on Tableau Server or Tableau Cloud. The SiteItem class defines the
+    information you can request or query from Tableau Server or Tableau Cloud.
+    The class members correspond to the attributes of a server request or
+    response payload.
+
+    Attributes
+    ----------
+    name: str
+        The name of the site. The name of the default site is "".
+
+    content_url: str
+        The path to the site.
+
+    admin_mode: str
+        (Optional) For Tableau Server only. Specify ContentAndUsers to allow
+        site administrators to use the server interface and tabcmd commands to
+        add and remove users. (Specifying this option does not give site
+        administrators permissions to manage users using the REST API.) Specify
+        ContentOnly to prevent site administrators from adding or removing
+        users. (Server administrators can always add or remove users.)
+
+    user_quota: int
+        (Optional) Specifies the total number of users for the site. The number
+        can't exceed the number of licenses activated for the site; and if
+        tiered capacity attributes are set, then user_quota will equal the sum
+        of the tiered capacity values, and attempting to set user_quota will
+        cause an error.
+
+    tier_explorer_capacity: int
+    tier_creator_capacity: int
+    tier_viewer_capacity: int
+        (Optional) The maximum number of licenses for users with the Creator,
+        Explorer, or Viewer role, respectively, allowed on a site.
+
+    storage_quota: int
+        (Optional) Specifies the maximum amount of space for the new site, in
+        megabytes. If you set a quota and the site exceeds it, publishers will
+        be prevented from uploading new content until the site is under the
+        limit again.
+
+    disable_subscriptions: bool
+        (Optional) Specify true to prevent users from being able to subscribe
+        to workbooks on the specified site. The default is False.
+
+    subscribe_others_enabled: bool
+        (Optional) Specify false to prevent server administrators, site
+        administrators, and project or content owners from being able to
+        subscribe other users to workbooks on the specified site. The default
+        is True.
+
+    revision_history_enabled: bool
+        (Optional) Specify true to enable revision history for content resources
+        (workbooks and datasources). The default is False.
+
+    revision_limit: int
+        (Optional) Specifies the number of revisions of a content source
+        (workbook or data source) to allow. On Tableau Server, the default is
+        25.
+
+    state: str
+        Shows the current state of the site (Active or Suspended).
+
+    """
+
     _user_quota: Optional[int] = None
     _tier_creator_capacity: Optional[int] = None
     _tier_explorer_capacity: Optional[int] = None
@@ -873,7 +939,7 @@ class SiteItem(object):
             self.auto_suspend_refresh_inactivity_window = auto_suspend_refresh_inactivity_window
 
     @classmethod
-    def from_response(cls, resp, ns) -> List["SiteItem"]:
+    def from_response(cls, resp, ns) -> list["SiteItem"]:
         all_site_items = list()
         parsed_response = fromstring(resp)
         all_site_xml = parsed_response.findall(".//t:site", namespaces=ns)

tableauserverclient/models/subscription_item.py

@@ -1,4 +1,4 @@
-from typing import List, Type, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from defusedxml.ElementTree import fromstring
 
@@ -10,7 +10,7 @@ if TYPE_CHECKING:
     from .target import Target
 
 
-class SubscriptionItem(object):
+class SubscriptionItem:
     def __init__(self, subject: str, schedule_id: str, user_id: str, target: "Target") -> None:
         self._id = None
         self.attach_image = True
@@ -79,7 +79,7 @@ class SubscriptionItem(object):
         self._suspended = value
 
     @classmethod
-    def from_response(cls: Type, xml: bytes, ns) -> List["SubscriptionItem"]:
+    def from_response(cls: type, xml: bytes, ns) -> list["SubscriptionItem"]:
         parsed_response = fromstring(xml)
         all_subscriptions_xml = parsed_response.findall(".//t:subscription", namespaces=ns)
 

tableauserverclient/models/table_item.py

@@ -4,7 +4,7 @@ from .exceptions import UnpopulatedPropertyError
 from .property_decorators import property_not_empty, property_is_boolean
 
 
-class TableItem(object):
+class TableItem:
     def __init__(self, name, description=None):
         self._id = None
         self.description = description

tableauserverclient/models/tableau_auth.py

@@ -1,5 +1,5 @@
 import abc
-from typing import Dict, Optional
+from typing import Optional
 
 
 class Credentials(abc.ABC):
@@ -9,7 +9,7 @@ class Credentials(abc.ABC):
 
     @property
     @abc.abstractmethod
-    def credentials(self) -> Dict[str, str]:
+    def credentials(self) -> dict[str, str]:
         credentials = (
             "Credentials can be username/password, Personal Access Token, or JWT"
             "This method returns values to set as an attribute on the credentials element of the request"
@@ -32,6 +32,43 @@ def deprecate_site_attribute():
 
 # The traditional auth type: username/password
 class TableauAuth(Credentials):
+    """
+    The TableauAuth class defines the information you can set in a sign-in
+    request. The class members correspond to the attributes of a server request
+    or response payload. To use this class, create a new instance, supplying
+    user name, password, and site information if necessary, and pass the
+    request object to the Auth.sign_in method.
+
+    Parameters
+    ----------
+    username : str
+        The user name for the sign-in request.
+
+    password : str
+        The password for the sign-in request.
+
+    site_id : str, optional
+        This corresponds to the contentUrl attribute in the Tableau REST API.
+        The site_id is the portion of the URL that follows the /site/ in the
+        URL. For example, "MarketingTeam" is the site_id in the following URL
+        MyServer/#/site/MarketingTeam/projects. To specify the default site on
+        Tableau Server, you can use an empty string '' (single quotes, no
+        space). For Tableau Cloud, you must provide a value for the site_id.
+
+    user_id_to_impersonate : str, optional
+        Specifies the id (not the name) of the user to sign in as. This is not
+        available for Tableau Online.
+
+    Examples
+    --------
+    >>> import tableauserverclient as TSC
+
+    >>> tableau_auth = TSC.TableauAuth('USERNAME', 'PASSWORD', site_id='CONTENTURL')
+    >>> server = TSC.Server('https://SERVER_URL', use_server_version=True)
+    >>> server.auth.sign_in(tableau_auth)
+
+    """
+
     def __init__(
         self, username: str, password: str, site_id: Optional[str] = None, user_id_to_impersonate: Optional[str] = None
     ) -> None:
@@ -42,7 +79,7 @@ class TableauAuth(Credentials):
         self.username = username
 
     @property
-    def credentials(self) -> Dict[str, str]:
+    def credentials(self) -> dict[str, str]:
         return {"name": self.username, "password": self.password}
 
     def __repr__(self):
@@ -55,6 +92,43 @@ class TableauAuth(Credentials):
 
 # A Tableau-generated Personal Access Token
 class PersonalAccessTokenAuth(Credentials):
+    """
+    The PersonalAccessTokenAuth class defines the information you can set in a sign-in
+    request. The class members correspond to the attributes of a server request
+    or response payload. To use this class, create a new instance, supplying
+    token name, token secret, and site information if necessary, and pass the
+    request object to the Auth.sign_in method.
+
+    Parameters
+    ----------
+    token_name : str
+        The name of the personal access token.
+
+    personal_access_token : str
+        The personal access token secret for the sign in request.
+
+    site_id : str, optional
+        This corresponds to the contentUrl attribute in the Tableau REST API.
+        The site_id is the portion of the URL that follows the /site/ in the
+        URL. For example, "MarketingTeam" is the site_id in the following URL
+        MyServer/#/site/MarketingTeam/projects. To specify the default site on
+        Tableau Server, you can use an empty string '' (single quotes, no
+        space). For Tableau Cloud, you must provide a value for the site_id.
+
+    user_id_to_impersonate : str, optional
+        Specifies the id (not the name) of the user to sign in as. This is not
+        available for Tableau Online.
+
+    Examples
+    --------
+    >>> import tableauserverclient as TSC
+
+    >>> tableau_auth = TSC.PersonalAccessTokenAuth("token_name", "token_secret", site_id='CONTENTURL')
+    >>> server = TSC.Server('https://SERVER_URL', use_server_version=True)
+    >>> server.auth.sign_in(tableau_auth)
+
+    """
+
     def __init__(
         self,
         token_name: str,
@@ -69,7 +143,7 @@ class PersonalAccessTokenAuth(Credentials):
         self.personal_access_token = personal_access_token
 
     @property
-    def credentials(self) -> Dict[str, str]:
+    def credentials(self) -> dict[str, str]:
         return {
             "personalAccessTokenName": self.token_name,
             "personalAccessTokenSecret": self.personal_access_token,
@@ -88,6 +162,42 @@ class PersonalAccessTokenAuth(Credentials):
 
 # A standard JWT generated specifically for Tableau
 class JWTAuth(Credentials):
+    """
+    The JWTAuth class defines the information you can set in a sign-in
+    request. The class members correspond to the attributes of a server request
+    or response payload. To use this class, create a new instance, supplying
+    an encoded JSON Web Token, and site information if necessary, and pass the
+    request object to the Auth.sign_in method.
+
+    Parameters
+    ----------
+    token : str
+        The encoded JSON Web Token.
+
+    site_id : str, optional
+        This corresponds to the contentUrl attribute in the Tableau REST API.
+        The site_id is the portion of the URL that follows the /site/ in the
+        URL. For example, "MarketingTeam" is the site_id in the following URL
+        MyServer/#/site/MarketingTeam/projects. To specify the default site on
+        Tableau Server, you can use an empty string '' (single quotes, no
+        space). For Tableau Cloud, you must provide a value for the site_id.
+
+    user_id_to_impersonate : str, optional
+        Specifies the id (not the name) of the user to sign in as. This is not
+        available for Tableau Online.
+
+    Examples
+    --------
+    >>> import jwt
+    >>> import tableauserverclient as TSC
+
+    >>> jwt_token = jwt.encode(...)
+    >>> tableau_auth = TSC.JWTAuth(token, site_id='CONTENTURL')
+    >>> server = TSC.Server('https://SERVER_URL', use_server_version=True)
+    >>> server.auth.sign_in(tableau_auth)
+
+    """
+
     def __init__(self, jwt: str, 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")
@@ -95,7 +205,7 @@ class JWTAuth(Credentials):
         self.jwt = jwt
 
     @property
-    def credentials(self) -> Dict[str, str]:
+    def credentials(self) -> dict[str, str]:
         return {"jwt": self.jwt}
 
     def __repr__(self):

tableauserverclient/models/tableau_types.py

@@ -28,8 +28,8 @@ class Resource:
 TableauItem = Union[DatasourceItem, FlowItem, MetricItem, ProjectItem, ViewItem, WorkbookItem, VirtualConnectionItem]
 
 
-def plural_type(content_type: Resource) -> str:
+def plural_type(content_type: Union[Resource, str]) -> str:
     if content_type == Resource.Lens:
         return "lenses"
     else:
-        return "{}s".format(content_type)
+        return f"{content_type}s"

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,7 @@ from tableauserverclient.models.schedule_item import ScheduleItem
 from tableauserverclient.models.target import Target
 
 
-class TaskItem(object):
+class TaskItem:
     class Type:
         ExtractRefresh = "extractRefresh"
         DataAcceleration = "dataAcceleration"
@@ -48,9 +48,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,7 +1,8 @@
 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
 
@@ -11,13 +12,13 @@ from .permissions_item import PermissionsRule
 from .tag_item import TagItem
 
 
-class ViewItem(object):
+class ViewItem:
     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 +30,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 +147,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: