dcicutils 8.13.3.1b26__tar.gz → 8.13.3.1b29__tar.gz

{dcicutils-8.13.3.1b26 → dcicutils-8.13.3.1b29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dcicutils
-Version: 8.13.3.1b26
+Version: 8.13.3.1b29
 Summary: Utility package for interacting with the 4DN Data Portal and other 4DN resources
 Home-page: https://github.com/4dn-dcic/utils
 License: MIT

{dcicutils-8.13.3.1b26 → dcicutils-8.13.3.1b29}/dcicutils/misc_utils.py

@@ -990,6 +990,10 @@ def to_integer(value: str,
                allow_commas: bool = False,
                allow_multiplier_suffix: bool = False,
                fallback: Optional[Union[int, float]] = None) -> Optional[int]:
+    """
+    Converts the given string value to an int or None or the given fallback value if malformed.
+    See comments in to_number for details on the other arguments.
+    """
     return to_number(value, fallback=fallback, as_float=False,
                      allow_commas=allow_commas,
                      allow_multiplier_suffix=allow_multiplier_suffix)
@@ -999,25 +1003,33 @@ def to_float(value: str,
              allow_commas: bool = False,
              allow_multiplier_suffix: bool = False,
              fallback: Optional[Union[int, float]] = None) -> Optional[int]:
+    """
+    Converts the given string value to a float or None or the given fallback value if malformed.
+    See comments in to_number for details on the other arguments.
+    """
     return to_number(value, fallback=fallback, as_float=True,
                      allow_commas=allow_commas,
                      allow_multiplier_suffix=allow_multiplier_suffix)
 
 
-_TO_NUMBER_MULTIPLIER_K = 1000
-_TO_NUMBER_MULTIPLIER_M = 1000 * _TO_NUMBER_MULTIPLIER_K
-_TO_NUMBER_MULTIPLIER_G = 1000 * _TO_NUMBER_MULTIPLIER_M
-_TO_NUMBER_MULTIPLIER_T = 1000 * _TO_NUMBER_MULTIPLIER_G
+_TO_NUMBER_POWER_OF_TEN_FOR_NOTHING = 0
+_TO_NUMBER_POWER_OF_TEN_FOR_K = 3
+_TO_NUMBER_POWER_OF_TEN_FOR_M = 6
+_TO_NUMBER_POWER_OF_TEN_FOR_G = 9
+_TO_NUMBER_POWER_OF_TEN_FOR_T = 12
 
 _TO_NUMBER_MULTIPLIER_SUFFIXES = {
-    "K": _TO_NUMBER_MULTIPLIER_K,
-    "KB": _TO_NUMBER_MULTIPLIER_K,
-    "M": _TO_NUMBER_MULTIPLIER_M,
-    "MB": _TO_NUMBER_MULTIPLIER_M,
-    "G": _TO_NUMBER_MULTIPLIER_G,
-    "GB": _TO_NUMBER_MULTIPLIER_G,
-    "T": _TO_NUMBER_MULTIPLIER_T,
-    "TB": _TO_NUMBER_MULTIPLIER_T
+    "K": _TO_NUMBER_POWER_OF_TEN_FOR_K,
+    "KB": _TO_NUMBER_POWER_OF_TEN_FOR_K,
+    "M": _TO_NUMBER_POWER_OF_TEN_FOR_M,
+    "MB": _TO_NUMBER_POWER_OF_TEN_FOR_M,
+    "G": _TO_NUMBER_POWER_OF_TEN_FOR_G,
+    "GB": _TO_NUMBER_POWER_OF_TEN_FOR_G,
+    "T": _TO_NUMBER_POWER_OF_TEN_FOR_T,
+    "TB": _TO_NUMBER_POWER_OF_TEN_FOR_T,
+    # B means bytes or bases and BP means base pairs; needs to be last.
+    "B": _TO_NUMBER_POWER_OF_TEN_FOR_NOTHING,
+    "BP": _TO_NUMBER_POWER_OF_TEN_FOR_NOTHING
 }
 
 
@@ -1027,24 +1039,32 @@ def to_number(value: str,
               allow_multiplier_suffix: bool = False,
               fallback: Optional[Union[int, float]] = None) -> Optional[Union[int, float]]:
     """
-    Converts the given string value to an int, or float if as_float is True, or None if malformed.
-    If allow_commas is True then allow commas (only) every three digits. If allow_multiplier_suffix
-    is True  allow any of K, KB; or M, MB; or G, or GB; or T, TB (case-insensitive), to mean multiply
-    value by one thousand; one million; one billion; or one trillion; respectively. If as_float is True
-    then value is parsed and returned as a float rather than int. Note that even if as_float is False,
-    values that might look like a float, can be an int, for example, "1.5K", returns 1500 as an int;
-    but "1.5002K" returns None, i.e. since 1.5002K is 1500.2 which is not an int.
+    Converts the given string value to an int, or float if as_float is True,
+    or None or the given fallback value if malformed.
+
+    If allow_commas is True then allows appropriately placed commas (i.e. every three digits).
+
+    If allow_multiplier_suffix is True allows any of the multiplier suffixes K, KB; M, MB;
+    or G, GB; or T, TB; all case-insensitive; which will multiply the value by a thousand;
+    a million; a billion; or a trillion; respectively.
+
+    If as_float is True then value is parsed and returned as a float rather than int.
+
+    Note that even if as_float is False, values that might LOOK like a float, can be
+    an int, for example, "1.5K", returns 1500 as an int since it is; but "1.5002K"
+    is malformed, since 1.5002K is equivalent to 1500.2 which is not an int.
     """
 
     if not (isinstance(value, str) and (value := value.strip())):
+        # Just in case the value is already the actual/desired return type.
         if as_float is True:
             return float(value) if isinstance(value, (float, int)) else fallback
         else:
             return value if isinstance(value, int) else fallback
 
-    value_multiplier = 1
-    value_negative = False
+    value_multiplier = _TO_NUMBER_POWER_OF_TEN_FOR_NOTHING
     value_fraction = None
+    value_negative = False
 
     if value.startswith("-"):
         if not (value := value[1:].strip()):
@@ -1058,28 +1078,27 @@ def to_number(value: str,
         value_upper = value.upper()
         for suffix in _TO_NUMBER_MULTIPLIER_SUFFIXES:
             if value_upper.endswith(suffix):
-                value_multiplier *= _TO_NUMBER_MULTIPLIER_SUFFIXES[suffix]
+                value_multiplier = _TO_NUMBER_MULTIPLIER_SUFFIXES[suffix]
                 if not (value := value[:-len(suffix)].strip()):
                     return fallback
                 break
 
     if (allow_multiplier_suffix is True) or (as_float is True):
-        # Allow for example "1.5K" to mean 1500 (integer).
+        # Allow for example "1.5K" to mean 1500 (int).
         if (dot_index := value.rfind(".")) >= 0:
             if value_fraction := value[dot_index + 1:].strip():
-                try:
-                    value_fraction = float(f"0.{value_fraction}")
-                except Exception:
+                if not value_fraction.isdigit():
                     return fallback
             if not (value := value[:dot_index].strip()):
                 if not value_fraction:
                     return fallback
                 value = "0"
     elif (as_float is not True) and (value_dot_zero_suffix := re.search(r"\.0*$", value)):
-        # Allow for example "123.00" to mean 123 (integer).
+        # Allow for example "123.00" to mean 123 (int).
         value = value[:value_dot_zero_suffix.start()]
 
     if (allow_commas is True) and ("," in value):
+        # Make sure any commas are properly placed/spaced.
         if not re.fullmatch(r"(-?\d{1,3}(,\d{3})*)", value):
             return fallback
         value = value.replace(",", "")
@@ -1087,23 +1106,38 @@ def to_number(value: str,
     if not value.isdigit():
         return fallback
 
-    value = float(value) if as_float is True else int(value)
-
-    if value_fraction:
-        value_float = (float(value) + value_fraction) * float(value_multiplier)
-        if as_float is True:
-            value = value_float
+    if value_multiplier != _TO_NUMBER_POWER_OF_TEN_FOR_NOTHING:
+        # We do string manipulation for the (power of ten) multiplier and NOT normal multiplicative
+        # arithmetic because this can EASILY yield UNEXPECTED floating point related INACCURACIES.
+        # E.g. to_integer("1.5678K", allow_multiplier_suffix=True) would yield 1567.8000000000002
+        # rather than 1567.8 if (we simply did 1.5678 * 1000.0); also tried multiplying by 10 at
+        # a time, and using Decimal, which obviated some, but not all, of the idiosyncrasies.
+        if value_fraction:
+            for _ in range(value_multiplier):
+                if value_fraction:
+                    value += value_fraction[0]
+                    value_fraction = value_fraction[1:]
+                else:
+                    value += "0"
+            if value_fraction:
+                if as_float is not True:
+                    # Left over fraction for int with multiplier, e.g. "1.2345K" -> 1234.5.
+                    return fallback
+                value = float(f"{value}.{value_fraction}")
+            else:
+                value = float(value) if as_float else int(value)
+        else:
+            value = value + ("0" * value_multiplier)
+            value = float(value) if as_float else int(value)
+    elif as_float is True:
+        if value_fraction:
+            value = float(f"{value}.{value_fraction}")
         else:
-            value = int(value_float)
-            if value_float != value:
-                return fallback
+            value = float(value)
     else:
-        value *= value_multiplier
+        value = int(value)
 
-    if value_negative:
-        value = -value
-
-    return value
+    return -value if value_negative else value
 
 
 def to_boolean(value: str, fallback: Optional[Any]) -> Optional[Any]:

{dcicutils-8.13.3.1b26 → dcicutils-8.13.3.1b29}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dcicutils"
-version = "8.13.3.1b26"  # TODO: To become 8.14.0
+version = "8.13.3.1b29"  # TODO: To become 8.14.0
 description = "Utility package for interacting with the 4DN Data Portal and other 4DN resources"
 authors = ["4DN-DCIC Team <support@4dnucleome.org>"]
 license = "MIT"