toil 9.1.2__py3-none-any.whl → 9.2.0__py3-none-any.whl

toil/options/common.py

@@ -1,7 +1,8 @@
 import logging
 import os
 from argparse import Action, ArgumentParser, _AppendAction
-from typing import TYPE_CHECKING, Any, Callable, Optional, Union
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
 
 from configargparse import SUPPRESS
 from ruamel.yaml import YAML
@@ -23,7 +24,7 @@ SYS_MAX_SIZE = 9223372036854775807
 # use the same number
 
 
-def parse_set_env(l: list[str]) -> dict[str, Optional[str]]:
+def parse_set_env(l: list[str]) -> dict[str, str | None]:
     """
     Parse a list of strings of the form "NAME=VALUE" or just "NAME" into a dictionary.
 
@@ -53,7 +54,7 @@ def parse_set_env(l: list[str]) -> dict[str, Optional[str]]:
     ValueError: Empty name
     """
     d = {}
-    v: Optional[str] = None
+    v: str | None = None
     for i in l:
         try:
             k, v = i.split("=", 1)
@@ -73,7 +74,7 @@ def parse_int_list(s: str) -> list[int]:
     return [int(x) for x in s.split(",")]
 
 
-def iC(min_value: int, max_value: Optional[int] = None) -> Callable[[int], bool]:
+def iC(min_value: int, max_value: int | None = None) -> Callable[[int], bool]:
     """Returns a function that checks if a given int is in the given half-open interval."""
     assert isinstance(min_value, int)
     if max_value is None:
@@ -82,7 +83,7 @@ def iC(min_value: int, max_value: Optional[int] = None) -> Callable[[int], bool]
     return lambda x: min_value <= x < max_value
 
 
-def fC(minValue: float, maxValue: Optional[float] = None) -> Callable[[float], bool]:
+def fC(minValue: float, maxValue: float | None = None) -> Callable[[float], bool]:
     """Returns a function that checks if a given float is in the given half-open interval."""
     assert isinstance(minValue, float)
     if maxValue is None:
@@ -91,7 +92,7 @@ def fC(minValue: float, maxValue: Optional[float] = None) -> Callable[[float], b
     return lambda x: minValue <= x < maxValue
 
 
-def parse_accelerator_list(specs: Optional[str]) -> list["AcceleratorRequirement"]:
+def parse_accelerator_list(specs: str | None) -> list["AcceleratorRequirement"]:
     """
     Parse a string description of one or more accelerator requirements.
     """
@@ -116,7 +117,7 @@ def parseBool(val: str) -> bool:
 
 # This is kept in the outer scope as multiple batchsystem files use this
 def make_open_interval_action(
-    min: Union[int, float], max: Optional[Union[int, float]] = None
+    min: int | float, max: int | float | None = None
 ) -> type[Action]:
     """
     Returns an argparse action class to check if the input is within the given half-open interval.
@@ -286,7 +287,7 @@ def add_base_toil_options(
             setattr(namespace, self.dest, coordination_dir)
 
     def make_closed_interval_action(
-        min: Union[int, float], max: Optional[Union[int, float]] = None
+        min: int | float, max: int | float | None = None
     ) -> type[Action]:
         """
         Returns an argparse action class to check if the input is within the given half-open interval.
@@ -306,7 +307,7 @@ def add_base_toil_options(
                 values: Any,
                 option_string: Any = None,
             ) -> None:
-                def is_within(x: Union[int, float]) -> bool:
+                def is_within(x: int | float) -> bool:
                     if max is None:
                         return min <= x
                     else:
@@ -467,8 +468,10 @@ def add_base_toil_options(
     )
 
     caching = file_store_options.add_mutually_exclusive_group()
-    caching_help = ("Enable or disable worker level file caching for your workflow, specifying this overrides default from batch system. "
-                    "Does not affect CWL or WDL task caching.")
+    caching_help = (
+        "Enable or disable worker level file caching for your workflow, specifying this overrides default from batch system. "
+        "Does not affect CWL or WDL task caching."
+    )
     caching.add_argument(
         "--caching",
         dest="caching",
@@ -1119,11 +1122,11 @@ def add_base_toil_options(
         default=None,
         help="Whether to publish workflow metrics reports (including unique workflow "
         "and task run IDs, job names, and version and Toil feature use information) to "
-        "Dockstore when a workflow completes. Selecting \"current\" will publish metrics "
-        "for the current workflow. Selecting \"all\" will also publish prior workflow "
-        "runs from the Toil history database, even if they themselves were run with \"no\". "
+        'Dockstore when a workflow completes. Selecting "current" will publish metrics '
+        'for the current workflow. Selecting "all" will also publish prior workflow '
+        'runs from the Toil history database, even if they themselves were run with "no". '
         "Note that once published, workflow metrics CANNOT be deleted or un-published; they "
-        "will stay published forever!"
+        "will stay published forever!",
     )
 
     # Debug options

toil/options/cwl.py

@@ -424,7 +424,7 @@ def add_cwl_options(parser: ArgumentParser, suppress: bool = True) -> None:
         or "Specify a minimum memory allocation for all tasks ."
         "If --no-cwl-default-ram is passed, this does not apply to tools that do not "
         "specify a memory requirement; --defaultMemory is used for those tools"
-        "in that case."
+        "in that case.",
     )
     parser.add_argument(
         "--destBucket",
@@ -439,5 +439,5 @@ def add_cwl_options(parser: ArgumentParser, suppress: bool = True) -> None:
         "recomputing steps. Can be very helpful in the development and "
         "troubleshooting of CWL documents. This automatically bypasses the file store."
         " Not to be confused with --caching.",
-        dest="cachedir"
+        dest="cachedir",
     )

toil/options/runner.py

@@ -1,4 +1,4 @@
-from argparse import ArgumentParser, SUPPRESS
+from argparse import SUPPRESS, ArgumentParser
 
 from toil.lib.conversions import human2bytes
 
@@ -39,7 +39,11 @@ def add_runner_options(
 
     # Deprecated
     parser.add_argument(
-        "--importWorkersThreshold", "--import-workers-threshold", dest="import_workers_batchsize",type=lambda x: human2bytes(str(x)), help=SUPPRESS
+        "--importWorkersThreshold",
+        "--import-workers-threshold",
+        dest="import_workers_batchsize",
+        type=lambda x: human2bytes(str(x)),
+        help=SUPPRESS,
     )
 
     import_workers_disk_argument = ["--importWorkersDisk"]
@@ -51,7 +55,7 @@ def add_runner_options(
         type=lambda x: human2bytes(str(x)),
         default="1 MiB",
         help="Specify the disk size each import worker will get. This usually will not need to be set as Toil will attempt to use file streaming when downloading files. "
-             "If not possible, for example, when downloading from AWS to a GCE job store, "
-             "this should be set to the largest file size of all files to import. This should be set in conjunction with the arguments "
-             "--runImportsOnWorkers and --importWorkersBatchSize."
+        "If not possible, for example, when downloading from AWS to a GCE job store, "
+        "this should be set to the largest file size of all files to import. This should be set in conjunction with the arguments "
+        "--runImportsOnWorkers and --importWorkersBatchSize."
     )

toil/options/wdl.py

@@ -87,9 +87,7 @@ def add_wdl_options(parser: ArgumentParser, suppress: bool = True) -> None:
         help=suppress_help or "Keep and return all call outputs as workflow outputs"
     )
 
-    strict_arguments = ["--wdlStrict"] + (
-        ["--strict"] if not suppress else []
-    )
+    strict_arguments = ["--wdlStrict"] + (["--strict"] if not suppress else [])
     parser.add_argument(
         *strict_arguments,
         dest="strict",

toil/provisioners/__init__.py

@@ -14,7 +14,7 @@
 import argparse
 import logging
 from difflib import get_close_matches
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
     from toil.provisioners.aws.awsProvisioner import AWSProvisioner
@@ -26,12 +26,12 @@ logger = logging.getLogger(__name__)
 
 def cluster_factory(
     provisioner: str,
-    clusterName: Optional[str] = None,
+    clusterName: str | None = None,
     clusterType: str = "mesos",
-    zone: Optional[str] = None,
+    zone: str | None = None,
     nodeStorage: int = 50,
-    nodeStorageOverrides: Optional[list[str]] = None,
-    sseKey: Optional[str] = None,
+    nodeStorageOverrides: list[str] | None = None,
+    sseKey: str | None = None,
     enable_fuse: bool = False,
 ) -> Union["AWSProvisioner", "GCEProvisioner"]:
     """
@@ -114,8 +114,8 @@ def add_provisioner_options(parser: argparse.ArgumentParser) -> None:
 
 
 def parse_node_types(
-    node_type_specs: Optional[str],
-) -> list[tuple[set[str], Optional[float]]]:
+    node_type_specs: str | None,
+) -> list[tuple[set[str], float | None]]:
     """
     Parse a specification for zero or more node types.
 
@@ -180,7 +180,7 @@ def parse_node_types(
 
 
 def check_valid_node_types(
-    provisioner, node_types: list[tuple[set[str], Optional[float]]]
+    provisioner, node_types: list[tuple[set[str], float | None]]
 ):
     """
     Raises if an invalid nodeType is specified for aws or gce.
@@ -256,7 +256,7 @@ class ClusterCombinationNotSupportedException(Exception):
         provisioner_class: type,
         cluster_type: str,
         architecture: str,
-        reason: Optional[str] = None,
+        reason: str | None = None,
     ):
         message = (
             f"The {provisioner_class} provisioner does not support making {cluster_type} clusters "

toil/provisioners/abstractProvisioner.py

@@ -20,7 +20,7 @@ import tempfile
 import textwrap
 from abc import ABC, abstractmethod
 from functools import total_ordering
-from typing import Any, Optional, Union
+from typing import Any
 from urllib.parse import quote
 from uuid import uuid4
 
@@ -58,9 +58,9 @@ class Shape:
 
     def __init__(
         self,
-        wallTime: Union[int, float],
+        wallTime: int | float,
         memory: int,
-        cores: Union[int, float],
+        cores: int | float,
         disk: int,
         preemptible: bool,
     ) -> None:
@@ -107,12 +107,14 @@ class Shape:
         return self.greater_than(other)
 
     def __repr__(self) -> str:
-        return "Shape(wallTime=%s, memory=%s, cores=%s, disk=%s, preemptible=%s)" % (
-            self.wallTime,
-            self.memory,
-            self.cores,
-            self.disk,
-            self.preemptible,
+        return (
+            "Shape(wallTime={}, memory={}, cores={}, disk={}, preemptible={})".format(
+                self.wallTime,
+                self.memory,
+                self.cores,
+                self.disk,
+                self.preemptible,
+            )
         )
 
     def __str__(self) -> str:
@@ -133,11 +135,11 @@ class AbstractProvisioner(ABC):
 
     def __init__(
         self,
-        clusterName: Optional[str] = None,
-        clusterType: Optional[str] = "mesos",
-        zone: Optional[str] = None,
+        clusterName: str | None = None,
+        clusterType: str | None = "mesos",
+        zone: str | None = None,
         nodeStorage: int = 50,
-        nodeStorageOverrides: Optional[list[str]] = None,
+        nodeStorageOverrides: list[str] | None = None,
         enable_fuse: bool = False,
     ) -> None:
         """
@@ -164,7 +166,7 @@ class AbstractProvisioner(ABC):
         for override in nodeStorageOverrides or []:
             nodeShape, storageOverride = override.split(":")
             self._nodeStorageOverrides[nodeShape] = int(storageOverride)
-        self._leaderPrivateIP: Optional[str] = None
+        self._leaderPrivateIP: str | None = None
         # This will hold an SSH public key for Mesos clusters, or the
         # Kubernetes joining information as a dict for Kubernetes clusters.
         self._leaderWorkerAuthentication = None
@@ -353,7 +355,7 @@ class AbstractProvisioner(ABC):
         # it.
         return dict(config["DEFAULT"])
 
-    def setAutoscaledNodeTypes(self, nodeTypes: list[tuple[set[str], Optional[float]]]):
+    def setAutoscaledNodeTypes(self, nodeTypes: list[tuple[set[str], float | None]]):
         """
         Set node types, shapes and spot bids for Toil-managed autoscaling.
         :param nodeTypes: A list of node types, as parsed with parse_node_types.
@@ -432,7 +434,7 @@ class AbstractProvisioner(ABC):
         nodeTypes: set[str],
         numNodes: int,
         preemptible: bool,
-        spotBid: Optional[float] = None,
+        spotBid: float | None = None,
     ) -> int:
         """
         Used to add worker nodes to the cluster
@@ -483,7 +485,7 @@ class AbstractProvisioner(ABC):
 
     @abstractmethod
     def getProvisionedWorkers(
-        self, instance_type: Optional[str] = None, preemptible: Optional[bool] = None
+        self, instance_type: str | None = None, preemptible: bool | None = None
     ) -> list[Node]:
         """
         Gets all nodes, optionally of the given instance type or
@@ -535,7 +537,7 @@ class AbstractProvisioner(ABC):
             self,
             path: str,
             filesystem: str = "root",
-            mode: Union[str, int] = "0755",
+            mode: str | int = "0755",
             contents: str = "",
             append: bool = False,
         ):
@@ -1060,7 +1062,7 @@ class AbstractProvisioner(ABC):
         """
         raise NotImplementedError()
 
-    def getKubernetesCloudProvider(self) -> Optional[str]:
+    def getKubernetesCloudProvider(self) -> str | None:
         """
         Return the Kubernetes cloud provider (for example, 'aws'), to pass to
         the kubelets in a Kubernetes cluster provisioned using this provisioner.
@@ -1390,7 +1392,7 @@ class AbstractProvisioner(ABC):
     def _getIgnitionUserData(
         self,
         role: str,
-        keyPath: Optional[str] = None,
+        keyPath: str | None = None,
         preemptible: bool = False,
         architecture: str = "amd64",
     ) -> str:

toil/provisioners/aws/__init__.py

@@ -16,7 +16,7 @@ import logging
 from collections import namedtuple
 from operator import attrgetter
 from statistics import mean, stdev
-from typing import Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from botocore.client import BaseClient
 
@@ -37,11 +37,11 @@ if TYPE_CHECKING:
 
 
 def get_aws_zone_from_spot_market(
-    spotBid: Optional[float],
-    nodeType: Optional[str],
-    boto3_ec2: Optional[BaseClient],
-    zone_options: Optional[list[str]],
-) -> Optional[str]:
+    spotBid: float | None,
+    nodeType: str | None,
+    boto3_ec2: BaseClient | None,
+    zone_options: list[str] | None,
+) -> str | None:
     """
     If a spot bid, node type, and Boto2 EC2 connection are specified, picks a
     zone where instances are easy to buy from the zones in the region of the
@@ -72,11 +72,11 @@ def get_aws_zone_from_spot_market(
 
 
 def get_best_aws_zone(
-    spotBid: Optional[float] = None,
-    nodeType: Optional[str] = None,
-    boto3_ec2: Optional[BaseClient] = None,
-    zone_options: Optional[list[str]] = None,
-) -> Optional[str]:
+    spotBid: float | None = None,
+    nodeType: str | None = None,
+    boto3_ec2: BaseClient | None = None,
+    zone_options: list[str] | None = None,
+) -> str | None:
     """
     Get the right AWS zone to use.
 
@@ -158,7 +158,9 @@ def choose_spot_zone(
             if zone_history["AvailabilityZone"] == zone
         ]
         if zone_histories:
-            price_deviation = stdev([float(history["SpotPrice"]) for history in zone_histories])
+            price_deviation = stdev(
+                [float(history["SpotPrice"]) for history in zone_histories]
+            )
             recent_price = float(zone_histories[0]["SpotPrice"])
         else:
             price_deviation, recent_price = 0.0, bid
@@ -188,7 +190,9 @@ def optimize_spot_bid(
     return most_stable_zone
 
 
-def _check_spot_bid(spot_bid: float, spot_history: list["SpotPriceTypeDef"], name: Optional[str] = None) -> None:
+def _check_spot_bid(
+    spot_bid: float, spot_history: list["SpotPriceTypeDef"], name: str | None = None
+) -> None:
     """
     Prevents users from potentially over-paying for instances
 
@@ -228,7 +232,9 @@ def _check_spot_bid(spot_bid: float, spot_history: list["SpotPriceTypeDef"], nam
         )
 
 
-def _get_spot_history(boto3_ec2: BaseClient, instance_type: str) -> list["SpotPriceTypeDef"]:
+def _get_spot_history(
+    boto3_ec2: BaseClient, instance_type: str
+) -> list["SpotPriceTypeDef"]:
     """
     Returns list of 1,000 most recent spot market data points represented as SpotPriceHistory
     objects. Note: The most recent object/data point will be first in the list.

toil/provisioners/aws/awsProvisioner.py

@@ -23,10 +23,10 @@ import string
 import textwrap
 import time
 import uuid
-from collections.abc import Collection, Iterable
+from collections.abc import Callable, Collection, Iterable
 from functools import wraps
 from shlex import quote
-from typing import TYPE_CHECKING, Any, Callable, Literal, TypeVar, cast
+from typing import TYPE_CHECKING, Any, Literal, TypeVar, cast
 
 # We need these to exist as attributes we can get off of the boto object
 from botocore.exceptions import ClientError
@@ -325,7 +325,9 @@ class AWSProvisioner(AbstractProvisioner):
         self._worker_subnets_by_zone = self._get_good_subnets_like(self._leader_subnet)
 
         # Find the SSH key name to use to start instances
-        if hasattr(ec2_metadata, 'public_keys') and isinstance(ec2_metadata.public_keys, dict):
+        if hasattr(ec2_metadata, "public_keys") and isinstance(
+            ec2_metadata.public_keys, dict
+        ):
             key_names = list(ec2_metadata.public_keys.keys())
             if len(key_names) > 0 and isinstance(key_names[0], str):
                 # We have a key name from the EC2 metadata. This should always
@@ -334,8 +336,10 @@ class AWSProvisioner(AbstractProvisioner):
                 # merged. Override anything from the tags.
                 self._keyName = key_names[0]
 
-        if not hasattr(self, '_keyName'):
-            raise RuntimeError("Unable to determine the SSH key name the cluster is using")
+        if not hasattr(self, "_keyName"):
+            raise RuntimeError(
+                "Unable to determine the SSH key name the cluster is using"
+            )
 
         self._leaderPrivateIP = ec2_metadata.private_ipv4  # this is PRIVATE IP
         self._tags = {
@@ -1021,9 +1025,7 @@ class AWSProvisioner(AbstractProvisioner):
         )
         # Boto 3 demands we base64 the user data ourselves *only* for spot
         # instances, and still wants a str.
-        spot_user_data = base64.b64encode(
-            userData.encode("utf-8")
-        ).decode("utf-8")
+        spot_user_data = base64.b64encode(userData.encode("utf-8")).decode("utf-8")
         spot_kwargs: dict[Literal["LaunchSpecification"], dict[str, Any]] = {
             "LaunchSpecification": {
                 "KeyName": self._keyName,

toil/provisioners/clusterScaler.py

@@ -18,7 +18,8 @@ import math
 import os
 import time
 from collections import defaultdict
-from typing import TYPE_CHECKING, Any, Callable, Optional, Union
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Union
 
 from toil.batchSystems.abstractBatchSystem import (
     AbstractBatchSystem,
@@ -45,7 +46,7 @@ logger = logging.getLogger(__name__)
 EVICTION_THRESHOLD = human2bytes("100MiB")
 RESERVE_SMALL_LIMIT = human2bytes("1GiB")
 RESERVE_SMALL_AMOUNT = human2bytes("255MiB")
-RESERVE_BREAKPOINTS: list[Union[int, float]] = [
+RESERVE_BREAKPOINTS: list[int | float] = [
     human2bytes("4GiB"),
     human2bytes("8GiB"),
     human2bytes("16GiB"),
@@ -120,7 +121,7 @@ class BinPackedFit:
 
     def addJobShape(
         self, jobShape: Shape
-    ) -> Optional[tuple[Shape, list[FailedConstraint]]]:
+    ) -> tuple[Shape, list[FailedConstraint]] | None:
         """
         Add the job to the first node reservation in which it will fit. (This
         is the bin-packing aspect).
@@ -141,7 +142,7 @@ class BinPackedFit:
                 jobShape,
             )
             # Go back and debug why this happened.
-            fewest_constraints: Optional[list[FailedConstraint]] = None
+            fewest_constraints: list[FailedConstraint] | None = None
             for shape in self.nodeShapes:
                 failures = NodeReservation(nodeShape).get_failed_constraints(jobShape)
                 if fewest_constraints is None or len(failures) < len(
@@ -199,7 +200,7 @@ class NodeReservation:
         # The wall-time of this slice and resources available in this timeslice
         self.shape = shape
         # The next portion of the reservation (None if this is the end)
-        self.nReservation: Optional[NodeReservation] = None
+        self.nReservation: NodeReservation | None = None
 
     def __str__(self) -> str:
         return (
@@ -290,7 +291,7 @@ class NodeReservation:
     def shapes(self) -> list[Shape]:
         """Get all time-slice shapes, in order, from this reservation on."""
         shapes = []
-        curRes: Optional[NodeReservation] = self
+        curRes: NodeReservation | None = self
         while curRes is not None:
             shapes.append(curRes.shape)
             curRes = curRes.nReservation
@@ -316,7 +317,7 @@ class NodeReservation:
         is a reservation for, and targetTime is the maximum time to wait before starting this job.
         """
         # starting slice of time that we can fit in so far
-        startingReservation: Optional[NodeReservation] = self
+        startingReservation: NodeReservation | None = self
         # current end of the slices we can fit in so far
         endingReservation = self
         # the amount of runtime of the job currently covered by slices
@@ -644,7 +645,7 @@ class ClusterScaler:
         # How many bytes are reserved so far?
         reserved = 0.0
         # How many bytes of memory have we accounted for so far?
-        accounted: Union[float, int] = 0
+        accounted: float | int = 0
         for breakpoint, fraction in zip(RESERVE_BREAKPOINTS, RESERVE_FRACTIONS):
             # Below each breakpoint, reserve the matching portion of the memory
             # since the previous breakpoint, like a progressive income tax.
@@ -1157,7 +1158,7 @@ class ClusterScaler:
         )
         return filtered_nodes
 
-    def getNodes(self, preemptible: Optional[bool] = None) -> dict["Node", NodeInfo]:
+    def getNodes(self, preemptible: bool | None = None) -> dict["Node", NodeInfo]:
         """
         Returns a dictionary mapping node identifiers of preemptible or non-preemptible nodes to
         NodeInfo objects, one for each node.
@@ -1253,9 +1254,9 @@ class JobTooBigError(Exception):
 
     def __init__(
         self,
-        job: Optional[JobDescription] = None,
-        shape: Optional[Shape] = None,
-        constraints: Optional[list[FailedConstraint]] = None,
+        job: JobDescription | None = None,
+        shape: Shape | None = None,
+        constraints: list[FailedConstraint] | None = None,
     ):
         """
         Make a JobTooBigError.
@@ -1398,8 +1399,8 @@ class ScalerThread(ExceptionalThread):
 
                     if len(could_not_fit) != 0:
                         # If we have any jobs left over that we couldn't fit, complain.
-                        bad_job: Optional[JobDescription] = None
-                        bad_shape: Optional[Shape] = None
+                        bad_job: JobDescription | None = None
+                        bad_shape: Shape | None = None
                         for job, shape in zip(queuedJobs, queuedJobShapes):
                             # Try and find an example job with an offending shape
                             if shape in could_not_fit:
@@ -1430,7 +1431,7 @@ class ScalerThread(ExceptionalThread):
 
 class ClusterStats:
     def __init__(
-        self, path: str, batchSystem: AbstractBatchSystem, clusterName: Optional[str]
+        self, path: str, batchSystem: AbstractBatchSystem, clusterName: str | None
     ) -> None:
         logger.debug("Initializing cluster statistics")
         self.stats: dict[str, dict[str, list[dict[str, Any]]]] = {}
@@ -1439,7 +1440,7 @@ class ClusterStats:
         self.stop = False
         self.clusterName = clusterName
         self.batchSystem = batchSystem
-        self.scaleable = (
+        self.scalable = (
             isinstance(self.batchSystem, AbstractScalableBatchSystem)
             if batchSystem
             else False
@@ -1460,7 +1461,7 @@ class ClusterStats:
                     return fullName
                 counter += 1
 
-        if self.statsPath and self.scaleable:
+        if self.statsPath and self.scalable:
             self.stop = True
             for thread in self.statsThreads:
                 thread.join()
@@ -1492,7 +1493,7 @@ class ClusterStats:
                 time=time.time(),  # add time stamp
             )
 
-        if self.scaleable:
+        if self.scalable:
             logger.debug("Starting to gather statistics")
             stats: dict[str, list[dict[str, Any]]] = {}
             if not isinstance(self.batchSystem, AbstractScalableBatchSystem):

toil/provisioners/gceProvisioner.py

@@ -17,7 +17,6 @@ import os
 import threading
 import time
 import uuid
-from typing import Optional
 
 from libcloud.compute.drivers.gce import GCEFailedNode
 from libcloud.compute.providers import get_driver
@@ -393,7 +392,7 @@ class GCEProvisioner(AbstractProvisioner):
         return workersCreated
 
     def getProvisionedWorkers(
-        self, instance_type: Optional[str] = None, preemptible: Optional[bool] = None
+        self, instance_type: str | None = None, preemptible: bool | None = None
     ):
         assert self._leaderPrivateIP
         entireCluster = self._getNodesInCluster(instance_type=instance_type)
@@ -460,7 +459,7 @@ class GCEProvisioner(AbstractProvisioner):
         if botoExists:
             node.injectFile(self._botoPath, self.NODE_BOTO_PATH, "toil_worker")
 
-    def _getNodesInCluster(self, instance_type: Optional[str] = None):
+    def _getNodesInCluster(self, instance_type: str | None = None):
         instanceGroup = self._gceDriver.ex_get_instancegroup(
             self.clusterName, zone=self._zone
         )