toil 6.1.0a1__py3-none-any.whl → 8.0.0__py3-none-any.whl

toil/lib/bioio.py

@@ -27,15 +27,19 @@ def system(command):
     will be passed to subprocess.check_call.
     :type command: str | sequence[string]
     """
-    logger.warning('Deprecated toil method that will be moved/replaced in a future release."')
-    logger.debug(f'Running: {command}')
+    logger.warning(
+        'Deprecated toil method that will be moved/replaced in a future release."'
+    )
+    logger.debug(f"Running: {command}")
     subprocess.check_call(command, shell=isinstance(command, str), bufsize=-1)
 
 
 # Used by cactus; now a wrapper and not used in Toil.
 # TODO: Remove from cactus and then remove from Toil.
 def getLogLevelString(logger=None):
-    root_logger.warning('Deprecated toil method.  Please call "logging.getLevelName" directly.')
+    root_logger.warning(
+        'Deprecated toil method.  Please call "logging.getLevelName" directly.'
+    )
     if logger is None:
         logger = root_logger
     return logging.getLevelName(logger.getEffectiveLevel())
@@ -44,12 +48,16 @@ def getLogLevelString(logger=None):
 # Used by cactus; now a wrapper and not used in Toil.
 # TODO: Remove from cactus and then remove from Toil.
 def setLoggingFromOptions(options):
-    logger.warning('Deprecated toil method.  Please use "toil.statsAndLogging.set_logging_from_options()" instead."')
+    logger.warning(
+        'Deprecated toil method.  Please use "toil.statsAndLogging.set_logging_from_options()" instead."'
+    )
     set_logging_from_options(options)
 
 
 # Used by cactus; now a wrapper and not used in Toil.
 # TODO: Remove from cactus and then remove from Toil.
 def getTempFile(suffix="", rootDir=None):
-    logger.warning('Deprecated toil method.  Please use "toil.test.get_temp_file()" instead."')
+    logger.warning(
+        'Deprecated toil method.  Please use "toil.test.get_temp_file()" instead."'
+    )
     return get_temp_file(suffix, rootDir)

toil/lib/compatibility.py

@@ -7,15 +7,20 @@ def deprecated(new_function_name: str) -> Callable[..., Any]:
     def decorate(func: Callable[..., Any]) -> Callable[..., Any]:
         @functools.wraps(func)
         def call(*args: Any, **kwargs: Any) -> Any:
-            warnings.warn(f'WARNING: "{func.__name__}()" is deprecated.  Please use "{new_function_name}()" instead.',
-                          DeprecationWarning)
+            warnings.warn(
+                f'WARNING: "{func.__name__}()" is deprecated.  Please use "{new_function_name}()" instead.',
+                DeprecationWarning,
+            )
             return func(*args, **kwargs)
+
         return call
+
     return decorate
 
 
 def compat_bytes(s: Union[bytes, str]) -> str:
-    return s.decode('utf-8') if isinstance(s, bytes) else s
+    return s.decode("utf-8") if isinstance(s, bytes) else s
+
 
 # MyPy can't yet support the recursive type we would need to say "we go through
 # any structure of dicts, tuples, lists, and sets and convert all bytes types
@@ -28,13 +33,13 @@ def compat_bytes_recursive(data: Any) -> Any:
     """
     if isinstance(data, dict):
         # Keyed collection
-        return type(data)((compat_bytes_recursive(i) for i in data.items()))
+        return type(data)(compat_bytes_recursive(i) for i in data.items())
     elif isinstance(data, (tuple, list, set)):
         # Flat collection
-        return type(data)((compat_bytes_recursive(i) for i in data))
+        return type(data)(compat_bytes_recursive(i) for i in data)
     elif isinstance(data, bytes):
         # Leaf bytes
-        return data.decode('utf-8')
+        return data.decode("utf-8")
     else:
         # Leaf non-bytes
         return data

toil/lib/conversions.py

@@ -4,68 +4,99 @@ Also contains general conversion functions
 """
 
 import math
-from typing import SupportsInt, Tuple, Union
+from typing import Optional, SupportsInt, Union
 
 # See https://en.wikipedia.org/wiki/Binary_prefix
-BINARY_PREFIXES = ['ki', 'mi', 'gi', 'ti', 'pi', 'ei', 'kib', 'mib', 'gib', 'tib', 'pib', 'eib']
-DECIMAL_PREFIXES = ['b', 'k', 'm', 'g', 't', 'p', 'e', 'kb', 'mb', 'gb', 'tb', 'pb', 'eb']
+BINARY_PREFIXES = [
+    "ki",
+    "mi",
+    "gi",
+    "ti",
+    "pi",
+    "ei",
+    "kib",
+    "mib",
+    "gib",
+    "tib",
+    "pib",
+    "eib",
+]
+DECIMAL_PREFIXES = [
+    "b",
+    "k",
+    "m",
+    "g",
+    "t",
+    "p",
+    "e",
+    "kb",
+    "mb",
+    "gb",
+    "tb",
+    "pb",
+    "eb",
+]
 VALID_PREFIXES = BINARY_PREFIXES + DECIMAL_PREFIXES
 
 
-def bytes_in_unit(unit: str = 'B') -> int:
+def bytes_in_unit(unit: str = "B") -> int:
     num_bytes = 1
-    if unit.lower() in ['ki', 'kib']:
+    if unit.lower() in ["ki", "kib"]:
         num_bytes = 1 << 10
-    if unit.lower() in ['mi', 'mib']:
+    if unit.lower() in ["mi", "mib"]:
         num_bytes = 1 << 20
-    if unit.lower() in ['gi', 'gib']:
+    if unit.lower() in ["gi", "gib"]:
         num_bytes = 1 << 30
-    if unit.lower() in ['ti', 'tib']:
+    if unit.lower() in ["ti", "tib"]:
         num_bytes = 1 << 40
-    if unit.lower() in ['pi', 'pib']:
+    if unit.lower() in ["pi", "pib"]:
         num_bytes = 1 << 50
-    if unit.lower() in ['ei', 'eib']:
+    if unit.lower() in ["ei", "eib"]:
         num_bytes = 1 << 60
 
-    if unit.lower() in ['k', 'kb']:
+    if unit.lower() in ["k", "kb"]:
         num_bytes = 1000
-    if unit.lower() in ['m', 'mb']:
-        num_bytes = 1000 ** 2
-    if unit.lower() in ['g', 'gb']:
-        num_bytes = 1000 ** 3
-    if unit.lower() in ['t', 'tb']:
-        num_bytes = 1000 ** 4
-    if unit.lower() in ['p', 'pb']:
-        num_bytes = 1000 ** 5
-    if unit.lower() in ['e', 'eb']:
-        num_bytes = 1000 ** 6
+    if unit.lower() in ["m", "mb"]:
+        num_bytes = 1000**2
+    if unit.lower() in ["g", "gb"]:
+        num_bytes = 1000**3
+    if unit.lower() in ["t", "tb"]:
+        num_bytes = 1000**4
+    if unit.lower() in ["p", "pb"]:
+        num_bytes = 1000**5
+    if unit.lower() in ["e", "eb"]:
+        num_bytes = 1000**6
     return num_bytes
 
 
-def convert_units(num: float,
-                  src_unit: str,
-                  dst_unit: str = 'B') -> float:
+def convert_units(num: float, src_unit: str, dst_unit: str = "B") -> float:
     """Returns a float representing the converted input in dst_units."""
     if not src_unit.lower() in VALID_PREFIXES:
-        raise RuntimeError(f"{src_unit} not a valid unit, valid units are {VALID_PREFIXES}.")
+        raise RuntimeError(
+            f"{src_unit} not a valid unit, valid units are {VALID_PREFIXES}."
+        )
     if not dst_unit.lower() in VALID_PREFIXES:
-        raise RuntimeError(f"{dst_unit} not a valid unit, valid units are {VALID_PREFIXES}.")
+        raise RuntimeError(
+            f"{dst_unit} not a valid unit, valid units are {VALID_PREFIXES}."
+        )
     return (num * bytes_in_unit(src_unit)) / bytes_in_unit(dst_unit)
 
 
-def parse_memory_string(string: str) -> Tuple[float, str]:
+def parse_memory_string(string: str) -> tuple[float, str]:
     """
     Given a string representation of some memory (i.e. '1024 Mib'), return the
     number and unit.
     """
     for i, character in enumerate(string):
         # find the first character of the unit
-        if character not in '0123456789.-_ ':
+        if character not in "0123456789.-_ ":
             units = string[i:].strip()
             if not units.lower() in VALID_PREFIXES:
-                raise RuntimeError(f"{units} not a valid unit, valid units are {VALID_PREFIXES}.")
+                raise RuntimeError(
+                    f"{units} not a valid unit, valid units are {VALID_PREFIXES}."
+                )
             return float(string[:i]), units
-    return float(string), 'b'
+    return float(string), "b"
 
 
 def human2bytes(string: str) -> int:
@@ -75,7 +106,7 @@ def human2bytes(string: str) -> int:
     """
     value, unit = parse_memory_string(string)
 
-    return int(convert_units(value, src_unit=unit, dst_unit='b'))
+    return int(convert_units(value, src_unit=unit, dst_unit="b"))
 
 
 def bytes2human(n: SupportsInt) -> str:
@@ -84,47 +115,73 @@ def bytes2human(n: SupportsInt) -> str:
     if n < 0:
         raise ValueError("n < 0")
     elif n < 1:
-        return '0 b'
+        return "0 b"
 
     power_level = math.floor(math.log(n, 1024))
-    units = ('b', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei')
+    units = ("b", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei")
 
     unit = units[power_level if power_level < len(units) else -1]
     value = convert_units(n, "b", unit)
-    return f'{value:.1f} {unit}'
-    
+    return f"{value:.1f} {unit}"
+
+
 def b_to_mib(n: Union[int, float]) -> float:
     """
     Convert a number from bytes to mibibytes.
     """
-    return convert_units(n, 'b', 'mib')
+    return convert_units(n, "b", "mib")
 
 
 def mib_to_b(n: Union[int, float]) -> float:
     """
     Convert a number from mibibytes to bytes.
     """
-    return convert_units(n, 'mib', 'b')
+    return convert_units(n, "mib", "b")
+
 
-#General Conversions
+# General Conversions
 
-def hms_duration_to_seconds(hms: str) -> float: 
+
+def hms_duration_to_seconds(hms: str) -> float:
     """
-    Parses a given time string in hours:minutes:seconds, 
+    Parses a given time string in hours:minutes:seconds,
     returns an equivalent total seconds value
     """
-    vals_to_convert = hms.split(':')
+    vals_to_convert = hms.split(":")
     seconds = 0.0
-    
+
     for val in vals_to_convert:
-        if(float(val) < 0): 
+        if float(val) < 0:
             raise ValueError("Invalid Time, negative value")
 
-    if(len(vals_to_convert) != 3):
+    if len(vals_to_convert) != 3:
         raise ValueError("Invalid amount of fields, function takes input in 'hh:mm:ss'")
 
-    seconds += float(vals_to_convert[0]) * 60 * 60 
-    seconds += float(vals_to_convert[1]) * 60 
-    seconds += float(vals_to_convert[2]) 
+    seconds += float(vals_to_convert[0]) * 60 * 60
+    seconds += float(vals_to_convert[1]) * 60
+    seconds += float(vals_to_convert[2])
 
     return seconds
+
+
+def strtobool(val: str) -> bool:
+    """
+    Make a human-readable string into a bool.
+
+    Convert a string along the lines of "y", "1", "ON", "TrUe", or
+    "Yes" to True, and the corresponding false-ish values to False.
+    """
+    # We only track prefixes, so "y" covers "y", "yes",
+    # and "yeah no" and makes them all True.
+    TABLE = {True: ["1", "on", "y", "t"], False: ["0", "off", "n", "f"]}
+    lowered = val.lower()
+    for result, prefixes in TABLE.items():
+        for prefix in prefixes:
+            if lowered.startswith(prefix):
+                return result
+    raise ValueError(f'Cannot convert "{val}" to a bool')
+
+
+def opt_strtobool(b: Optional[str]) -> Optional[bool]:
+    """Convert an optional string representation of bool to None or bool"""
+    return b if b is None else strtobool(b)