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

tableauserverclient/models/flow_item.py

@@ -1,22 +1,22 @@
 import copy
 import datetime
 import xml.etree.ElementTree as ET
-from typing import List, Optional, Set
+from typing import Optional
 
 from defusedxml.ElementTree import fromstring
 
 from tableauserverclient.datetime_helpers import parse_datetime
-from .connection_item import ConnectionItem
-from .dqw_item import DQWItem
-from .exceptions import UnpopulatedPropertyError
-from .permissions_item import Permission
-from .property_decorators import property_not_nullable
-from .tag_item import TagItem
+from tableauserverclient.models.connection_item import ConnectionItem
+from tableauserverclient.models.dqw_item import DQWItem
+from tableauserverclient.models.exceptions import UnpopulatedPropertyError
+from tableauserverclient.models.permissions_item import Permission
+from tableauserverclient.models.property_decorators import property_not_nullable
+from tableauserverclient.models.tag_item import TagItem
 
 
-class FlowItem(object):
+class FlowItem:
     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,13 +24,13 @@ 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
@@ -170,7 +170,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,7 @@ if TYPE_CHECKING:
     from tableauserverclient.server import Pager
 
 
-class GroupItem(object):
+class GroupItem:
     tag_name: str = "group"
 
     class LicenseMode:
@@ -27,7 +27,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 +79,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

@@ -0,0 +1,53 @@
+from typing import Optional
+import xml.etree.ElementTree as ET
+
+from defusedxml.ElementTree import fromstring
+
+from tableauserverclient.models.group_item import GroupItem
+from tableauserverclient.models.reference_item import ResourceReference
+
+
+class GroupSetItem:
+    tag_name: str = "groupSet"
+
+    def __init__(self, name: Optional[str] = None) -> None:
+        self.name = name
+        self.id: Optional[str] = None
+        self.groups: list["GroupItem"] = []
+        self.group_count: int = 0
+
+    def __str__(self) -> str:
+        name = self.name
+        id = self.id
+        return f"<{self.__class__.__qualname__}({name=}, {id=})>"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    @classmethod
+    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 get_group(group_xml: ET.Element) -> GroupItem:
+            group_item = GroupItem()
+            group_item._id = group_xml.get("id")
+            group_item.name = group_xml.get("name")
+            return group_item
+
+        group_set_item = cls()
+        group_set_item.name = groupset_xml.get("name")
+        group_set_item.id = groupset_xml.get("id")
+        group_set_item.group_count = int(count) if (count := groupset_xml.get("groupCount")) else 0
+        group_set_item.groups = [
+            get_group(group_xml) for group_xml in groupset_xml.findall(".//t:group", namespaces=ns)
+        ]
+
+        return group_set_item
+
+    @staticmethod
+    def as_reference(id_: str) -> ResourceReference:
+        return ResourceReference(id_, GroupSetItem.tag_name)

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
 
@@ -246,21 +246,34 @@ class MonthlyInterval(object):
 
     @interval.setter
     def interval(self, interval_values):
-        # This is weird because the value could be a str or an int
-        # The only valid str is 'LastDay' so we check that first. If that's not it
-        # try to convert it to an int, if that fails because it's an incorrect string
-        # like 'badstring' we catch and re-raise. Otherwise we convert to int and check
-        # that it's in range 1-31
+        # Valid monthly intervals strings can contain any of the following
+        #   day numbers (1-31) (integer or string)
+        #   relative day within the month (First, Second, ... Last)
+        #   week days (Sunday, Monday, ... LastDay)
+        VALID_INTERVALS = [
+            "Sunday",
+            "Monday",
+            "Tuesday",
+            "Wednesday",
+            "Thursday",
+            "Friday",
+            "Saturday",
+            "LastDay",
+            "First",
+            "Second",
+            "Third",
+            "Fourth",
+            "Fifth",
+            "Last",
+        ]
+        for value in range(1, 32):
+            VALID_INTERVALS.append(str(value))
+            VALID_INTERVALS.append(value)
+
         for interval_value in interval_values:
-            error = "Invalid interval value for a monthly frequency: {}.".format(interval_value)
-
-            if interval_value != "LastDay":
-                try:
-                    if not (1 <= int(interval_value) <= 31):
-                        raise ValueError(error)
-                except ValueError:
-                    if interval_value != "LastDay":
-                        raise ValueError(error)
+            if interval_value not in VALID_INTERVALS:
+                error = f"Invalid monthly interval: {interval_value}"
+                raise ValueError(error)
 
         self._interval = interval_values
 

tableauserverclient/models/job_item.py

@@ -1,13 +1,13 @@
 import datetime
-from typing import List, Optional
+from typing import Optional
 
 from defusedxml.ElementTree import fromstring
 
 from tableauserverclient.datetime_helpers import parse_datetime
-from .flow_run_item import FlowRunItem
+from tableauserverclient.models.flow_run_item import FlowRunItem
 
 
-class JobItem(object):
+class JobItem:
     class FinishCode:
         """
         Status codes as documented on
@@ -27,12 +27,14 @@ 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,
         flow_run: Optional[FlowRunItem] = None,
         updated_at: Optional[datetime.datetime] = None,
+        workbook_name: Optional[str] = None,
+        datasource_name: Optional[str] = None,
     ):
         self._id = id_
         self._type = job_type
@@ -41,12 +43,14 @@ 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
         self._flow_run = flow_run
         self._updated_at = updated_at
+        self._workbook_name = workbook_name
+        self._datasource_name = datasource_name
 
     @property
     def id(self) -> str:
@@ -77,7 +81,7 @@ class JobItem(object):
         return self._finish_code
 
     @property
-    def notes(self) -> List[str]:
+    def notes(self) -> list[str]:
         return self._notes
 
     @property
@@ -117,6 +121,14 @@ class JobItem(object):
     def updated_at(self) -> Optional[datetime.datetime]:
         return self._updated_at
 
+    @property
+    def workbook_name(self) -> Optional[str]:
+        return self._workbook_name
+
+    @property
+    def datasource_name(self) -> Optional[str]:
+        return self._datasource_name
+
     def __str__(self):
         return (
             "<Job#{_id} {_type} created_at({_created_at}) started_at({_started_at}) updated_at({_updated_at}) completed_at({_completed_at})"
@@ -127,7 +139,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)
 
@@ -148,8 +160,10 @@ class JobItem(object):
         mode = element.get("mode", None)
         workbook = element.find(".//t:workbook[@id]", namespaces=ns)
         workbook_id = workbook.get("id") if workbook is not None else None
+        workbook_name = workbook.get("name") if workbook is not None else None
         datasource = element.find(".//t:datasource[@id]", namespaces=ns)
         datasource_id = datasource.get("id") if datasource is not None else None
+        datasource_name = datasource.get("name") if datasource is not None else None
         flow_run = None
         updated_at = parse_datetime(element.get("updatedAt", None))
         for flow_job in element.findall(".//t:runFlowJobType", namespaces=ns):
@@ -172,10 +186,12 @@ class JobItem(object):
             datasource_id,
             flow_run,
             updated_at,
+            workbook_name,
+            datasource_name,
         )
 
 
-class BackgroundJobItem(object):
+class BackgroundJobItem:
     class Status:
         Pending: str = "Pending"
         InProgress: str = "InProgress"
@@ -206,7 +222,7 @@ class BackgroundJobItem(object):
         self._subtitle = subtitle
 
     def __str__(self):
-        return f"<{self.__class__.name} {self._id} {self._type}>"
+        return f"<{self.__class__.__qualname__} {self._id} {self._type}>"
 
     def __repr__(self):
         return self.__str__() + "  { " + ", ".join(" % s: % s" % item for item in vars(self).items()) + "}"
@@ -254,7 +270,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

@@ -0,0 +1,102 @@
+import datetime as dt
+from typing import Optional
+
+from defusedxml.ElementTree import fromstring
+
+from tableauserverclient.datetime_helpers import parse_datetime
+from tableauserverclient.models.schedule_item import ScheduleItem
+
+
+class LinkedTaskItem:
+    def __init__(self) -> None:
+        self.id: Optional[str] = None
+        self.num_steps: Optional[int] = None
+        self.schedule: Optional[ScheduleItem] = None
+
+    @classmethod
+    def from_response(cls, resp: bytes, namespace) -> list["LinkedTaskItem"]:
+        parsed_response = fromstring(resp)
+        return [
+            cls._parse_element(x, namespace)
+            for x in parsed_response.findall(".//t:linkedTasks[@id]", namespaces=namespace)
+        ]
+
+    @classmethod
+    def _parse_element(cls, xml, namespace) -> "LinkedTaskItem":
+        task = cls()
+        task.id = xml.get("id")
+        task.num_steps = int(xml.get("numSteps"))
+        task.schedule = ScheduleItem.from_element(xml, namespace)[0]
+        return task
+
+
+class LinkedTaskStepItem:
+    def __init__(self) -> None:
+        self.id: Optional[str] = None
+        self.step_number: Optional[int] = None
+        self.stop_downstream_on_failure: Optional[bool] = None
+        self.task_details: list[LinkedTaskFlowRunItem] = []
+
+    @classmethod
+    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
+    def _parse_element(cls, xml, namespace) -> "LinkedTaskStepItem":
+        step = cls()
+        step.id = xml.get("id")
+        step.step_number = int(xml.get("stepNumber"))
+        step.stop_downstream_on_failure = string_to_bool(xml.get("stopDownstreamTasksOnFailure"))
+        step.task_details = LinkedTaskFlowRunItem._parse_element(xml, namespace)
+        return step
+
+
+class LinkedTaskFlowRunItem:
+    def __init__(self) -> None:
+        self.flow_run_id: Optional[str] = None
+        self.flow_run_priority: Optional[int] = None
+        self.flow_run_consecutive_failed_count: Optional[int] = None
+        self.flow_run_task_type: Optional[str] = None
+        self.flow_id: Optional[str] = None
+        self.flow_name: Optional[str] = None
+
+    @classmethod
+    def _parse_element(cls, xml, namespace) -> list["LinkedTaskFlowRunItem"]:
+        all_tasks = []
+        for flow_run in xml.findall(".//t:flowRun[@id]", namespace):
+            task = cls()
+            task.flow_run_id = flow_run.get("id")
+            task.flow_run_priority = int(flow_run.get("priority"))
+            task.flow_run_consecutive_failed_count = int(flow_run.get("consecutiveFailedCount"))
+            task.flow_run_task_type = flow_run.get("type")
+            flow = flow_run.find(".//t:flow[@id]", namespace)
+            task.flow_id = flow.get("id")
+            task.flow_name = flow.get("name")
+            all_tasks.append(task)
+
+        return all_tasks
+
+
+class LinkedTaskJobItem:
+    def __init__(self) -> None:
+        self.id: Optional[str] = None
+        self.linked_task_id: Optional[str] = None
+        self.status: Optional[str] = None
+        self.created_at: Optional[dt.datetime] = None
+
+    @classmethod
+    def from_response(cls, resp: bytes, namespace) -> "LinkedTaskJobItem":
+        parsed_response = fromstring(resp)
+        job = cls()
+        job_xml = parsed_response.find(".//t:linkedTaskJob[@id]", namespaces=namespace)
+        if job_xml is None:
+            raise ValueError("No linked task job found in response")
+        job.id = job_xml.get("id")
+        job.linked_task_id = job_xml.get("linkedTaskId")
+        job.status = job_xml.get("status")
+        job.created_at = parse_datetime(job_xml.get("createdAt"))
+        return job
+
+
+def string_to_bool(s: str) -> bool:
+    return s.lower() == "true"

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,12 +1,13 @@
 import xml.etree.ElementTree as ET
-from typing import Dict, List, Optional
+from typing import Optional
 
 from defusedxml.ElementTree import fromstring
 
-from .exceptions import UnknownGranteeTypeError, UnpopulatedPropertyError
-from .group_item import GroupItem
-from .reference_item import ResourceReference
-from .user_item import UserItem
+from tableauserverclient.models.exceptions import UnknownGranteeTypeError, UnpopulatedPropertyError
+from tableauserverclient.models.group_item import GroupItem
+from tableauserverclient.models.groupset_item import GroupSetItem
+from tableauserverclient.models.reference_item import ResourceReference
+from tableauserverclient.models.user_item import UserItem
 
 from tableauserverclient.helpers.logging import logger
 
@@ -35,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"):
@@ -65,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)) == (
@@ -85,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)):
@@ -99,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)
 
@@ -115,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
@@ -126,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
@@ -142,7 +145,9 @@ class PermissionsRule:
             grantee = UserItem.as_reference(grantee_id)
         elif grantee_type == "group":
             grantee = GroupItem.as_reference(grantee_id)
+        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