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

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,7 @@ from tableauserverclient.datetime_helpers import parse_datetime
 from tableauserverclient.models.flow_run_item import FlowRunItem
 
 
-class JobItem(object):
+class JobItem:
     class FinishCode:
         """
         Status codes as documented on
@@ -27,7 +27,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 +43,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 +81,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 +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)
 
@@ -191,7 +191,7 @@ class JobItem(object):
         )
 
 
-class BackgroundJobItem(object):
+class BackgroundJobItem:
     class Status:
         Pending: str = "Pending"
         InProgress: str = "InProgress"
@@ -270,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

@@ -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

tableauserverclient/models/project_item.py

@@ -1,6 +1,6 @@
 import logging
 import xml.etree.ElementTree as ET
-from typing import List, Optional
+from typing import Optional
 
 from defusedxml.ElementTree import fromstring
 
@@ -8,14 +8,16 @@ from tableauserverclient.models.exceptions import UnpopulatedPropertyError
 from tableauserverclient.models.property_decorators import property_is_enum, property_not_empty
 
 
-class ProjectItem(object):
+class ProjectItem:
+    ERROR_MSG = "Project item must be populated with permissions first."
+
     class ContentPermissions:
         LockedToProject: str = "LockedToProject"
         ManagedByOwner: str = "ManagedByOwner"
         LockedToProjectWithoutNested: str = "LockedToProjectWithoutNested"
 
     def __repr__(self):
-        return "<Project {0} {1} parent={2} permissions={3}>".format(
+        return "<Project {} {} parent={} permissions={}>".format(
             self._id, self.name, self.parent_id or "None (Top level)", self.content_permissions or "Not Set"
         )
 
@@ -43,6 +45,9 @@ class ProjectItem(object):
         self._default_lens_permissions = None
         self._default_datarole_permissions = None
         self._default_metric_permissions = None
+        self._default_virtualconnection_permissions = None
+        self._default_database_permissions = None
+        self._default_table_permissions = None
 
     @property
     def content_permissions(self):
@@ -56,52 +61,63 @@ class ProjectItem(object):
     @property
     def permissions(self):
         if self._permissions is None:
-            error = "Project item must be populated with permissions first."
-            raise UnpopulatedPropertyError(error)
+            raise UnpopulatedPropertyError(self.ERROR_MSG)
         return self._permissions()
 
     @property
     def default_datasource_permissions(self):
         if self._default_datasource_permissions is None:
-            error = "Project item must be populated with permissions first."
-            raise UnpopulatedPropertyError(error)
+            raise UnpopulatedPropertyError(self.ERROR_MSG)
         return self._default_datasource_permissions()
 
     @property
     def default_workbook_permissions(self):
         if self._default_workbook_permissions is None:
-            error = "Project item must be populated with permissions first."
-            raise UnpopulatedPropertyError(error)
+            raise UnpopulatedPropertyError(self.ERROR_MSG)
         return self._default_workbook_permissions()
 
     @property
     def default_flow_permissions(self):
         if self._default_flow_permissions is None:
-            error = "Project item must be populated with permissions first."
-            raise UnpopulatedPropertyError(error)
+            raise UnpopulatedPropertyError(self.ERROR_MSG)
         return self._default_flow_permissions()
 
     @property
     def default_lens_permissions(self):
         if self._default_lens_permissions is None:
-            error = "Project item must be populated with permissions first."
-            raise UnpopulatedPropertyError(error)
+            raise UnpopulatedPropertyError(self.ERROR_MSG)
         return self._default_lens_permissions()
 
     @property
     def default_datarole_permissions(self):
         if self._default_datarole_permissions is None:
-            error = "Project item must be populated with permissions first."
-            raise UnpopulatedPropertyError(error)
+            raise UnpopulatedPropertyError(self.ERROR_MSG)
         return self._default_datarole_permissions()
 
     @property
     def default_metric_permissions(self):
         if self._default_metric_permissions is None:
-            error = "Project item must be populated with permissions first."
-            raise UnpopulatedPropertyError(error)
+            raise UnpopulatedPropertyError(self.ERROR_MSG)
         return self._default_metric_permissions()
 
+    @property
+    def default_virtualconnection_permissions(self):
+        if self._default_virtualconnection_permissions is None:
+            raise UnpopulatedPropertyError(self.ERROR_MSG)
+        return self._default_virtualconnection_permissions()
+
+    @property
+    def default_database_permissions(self):
+        if self._default_database_permissions is None:
+            raise UnpopulatedPropertyError(self.ERROR_MSG)
+        return self._default_database_permissions()
+
+    @property
+    def default_table_permissions(self):
+        if self._default_table_permissions is None:
+            raise UnpopulatedPropertyError(self.ERROR_MSG)
+        return self._default_table_permissions()
+
     @property
     def id(self) -> Optional[str]:
         return self._id
@@ -158,7 +174,7 @@ class ProjectItem(object):
         self._permissions = permissions
 
     def _set_default_permissions(self, permissions, content_type):
-        attr = "_default_{content}_permissions".format(content=content_type)
+        attr = f"_default_{content_type}_permissions"
         setattr(
             self,
             attr,
@@ -166,7 +182,7 @@ class ProjectItem(object):
         )
 
     @classmethod
-    def from_response(cls, resp, ns) -> List["ProjectItem"]:
+    def from_response(cls, resp, ns) -> list["ProjectItem"]:
         all_project_items = list()
         parsed_response = fromstring(resp)
         all_project_xml = parsed_response.findall(".//t:project", namespaces=ns)

tableauserverclient/models/property_decorators.py

@@ -1,7 +1,8 @@
 import datetime
 import re
 from functools import wraps
-from typing import Any, Container, Optional, Tuple
+from typing import Any, Optional
+from collections.abc import Container
 
 from tableauserverclient.datetime_helpers import parse_datetime
 
@@ -11,7 +12,7 @@ def property_is_enum(enum_type):
         @wraps(func)
         def wrapper(self, value):
             if value is not None and not hasattr(enum_type, value):
-                error = "Invalid value: {0}. {1} must be of type {2}.".format(value, func.__name__, enum_type.__name__)
+                error = f"Invalid value: {value}. {func.__name__} must be of type {enum_type.__name__}."
                 raise ValueError(error)
             return func(self, value)
 
@@ -24,7 +25,7 @@ def property_is_boolean(func):
     @wraps(func)
     def wrapper(self, value):
         if not isinstance(value, bool):
-            error = "Boolean expected for {0} flag.".format(func.__name__)
+            error = f"Boolean expected for {func.__name__} flag."
             raise ValueError(error)
         return func(self, value)
 
@@ -35,7 +36,7 @@ def property_not_nullable(func):
     @wraps(func)
     def wrapper(self, value):
         if value is None:
-            error = "{0} must be defined.".format(func.__name__)
+            error = f"{func.__name__} must be defined."
             raise ValueError(error)
         return func(self, value)
 
@@ -46,7 +47,7 @@ def property_not_empty(func):
     @wraps(func)
     def wrapper(self, value):
         if not value:
-            error = "{0} must not be empty.".format(func.__name__)
+            error = f"{func.__name__} must not be empty."
             raise ValueError(error)
         return func(self, value)
 
@@ -66,7 +67,7 @@ def property_is_valid_time(func):
     return wrapper
 
 
-def property_is_int(range: Tuple[int, int], allowed: Optional[Container[Any]] = None):
+def property_is_int(range: tuple[int, int], allowed: Optional[Container[Any]] = None):
     """Takes a range of ints and a list of exemptions to check against
     when setting a property on a model. The range is a tuple of (min, max) and the
     allowed list (empty by default) allows values outside that range.
@@ -81,7 +82,7 @@ def property_is_int(range: Tuple[int, int], allowed: Optional[Container[Any]] =
     def property_type_decorator(func):
         @wraps(func)
         def wrapper(self, value):
-            error = "Invalid property defined: '{}'. Integer value expected.".format(value)
+            error = f"Invalid property defined: '{value}'. Integer value expected."
 
             if range is None:
                 if isinstance(value, int):
@@ -133,7 +134,7 @@ def property_is_datetime(func):
             return func(self, value)
         if not isinstance(value, str):
             raise ValueError(
-                "Cannot convert {} into a datetime, cannot update {}".format(value.__class__.__name__, func.__name__)
+                f"Cannot convert {value.__class__.__name__} into a datetime, cannot update {func.__name__}"
             )
 
         dt = parse_datetime(value)
@@ -146,11 +147,11 @@ def property_is_data_acceleration_config(func):
     @wraps(func)
     def wrapper(self, value):
         if not isinstance(value, dict):
-            raise ValueError("{} is not type 'dict', cannot update {})".format(value.__class__.__name__, func.__name__))
+            raise ValueError(f"{value.__class__.__name__} is not type 'dict', cannot update {func.__name__})")
         if len(value) < 2 or not all(attr in value.keys() for attr in ("acceleration_enabled", "accelerate_now")):
-            error = "{} should have 2 keys ".format(func.__name__)
+            error = f"{func.__name__} should have 2 keys "
             error += "'acceleration_enabled' and 'accelerate_now'"
-            error += "instead you have {}".format(value.keys())
+            error += f"instead you have {value.keys()}"
             raise ValueError(error)
         return func(self, value)
 

tableauserverclient/models/reference_item.py

@@ -1,10 +1,10 @@
-class ResourceReference(object):
+class ResourceReference:
     def __init__(self, id_, tag_name):
         self.id = id_
         self.tag_name = tag_name
 
     def __str__(self):
-        return "<ResourceReference id={} tag={}>".format(self._id, self._tag_name)
+        return f"<ResourceReference id={self._id} tag={self._tag_name}>"
 
     __repr__ = __str__
 

tableauserverclient/models/revision_item.py

@@ -1,12 +1,12 @@
 from datetime import datetime
-from typing import List, Optional
+from typing import Optional
 
 from defusedxml.ElementTree import fromstring
 
 from tableauserverclient.datetime_helpers import parse_datetime
 
 
-class RevisionItem(object):
+class RevisionItem:
     def __init__(self):
         self._resource_id: Optional[str] = None
         self._resource_name: Optional[str] = None
@@ -56,7 +56,7 @@ class RevisionItem(object):
         )
 
     @classmethod
-    def from_response(cls, resp: bytes, ns, resource_item) -> List["RevisionItem"]:
+    def from_response(cls, resp: bytes, ns, resource_item) -> list["RevisionItem"]:
         all_revision_items = list()
         parsed_response = fromstring(resp)
         all_revision_xml = parsed_response.findall(".//t:revision", namespaces=ns)

tableauserverclient/models/schedule_item.py

@@ -19,7 +19,7 @@ from .property_decorators import (
 Interval = Union[HourlyInterval, DailyInterval, WeeklyInterval, MonthlyInterval]
 
 
-class ScheduleItem(object):
+class ScheduleItem:
     class Type:
         Extract = "Extract"
         Flow = "Flow"
@@ -336,7 +336,7 @@ class ScheduleItem(object):
         all_task_xml = parsed_response.findall(".//t:task", namespaces=ns)
 
         error = (
-            "Status {}: {}".format(response.status_code, response.reason)
+            f"Status {response.status_code}: {response.reason}"
             if response.status_code < 200 or response.status_code >= 300
             else None
         )