dcicutils 8.13.3.1b25__tar.gz → 8.13.3.1b27__tar.gz

{dcicutils-8.13.3.1b25 → dcicutils-8.13.3.1b27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dcicutils
-Version: 8.13.3.1b25
+Version: 8.13.3.1b27
 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.1b25 → dcicutils-8.13.3.1b27}/dcicutils/misc_utils.py

@@ -986,57 +986,73 @@ def str_to_bool(x: Optional[str]) -> Optional[bool]:
         raise ValueError(f"An argument to str_or_bool must be a string or None: {x!r}")
 
 
-def to_integer(value: str, fallback: Optional[Any] = None, strict: bool = False) -> Optional[Any]:
-    try:
-        return int(value)
-    except Exception:
-        if strict is not True:
-            try:
-                return int(float(value))
-            except Exception:
-                pass
-    return fallback
-
-
-_MULTIPLIER_K = 1000
-_MULTIPLIER_M = 1000 * _MULTIPLIER_K
-_MULTIPLIER_G = 1000 * _MULTIPLIER_M
-_MULTIPLIER_T = 1000 * _MULTIPLIER_G
-
-_MULTIPLIER_SUFFIXES = {
-    "K": _MULTIPLIER_K,
-    "KB": _MULTIPLIER_K,
-    "M": _MULTIPLIER_M,
-    "MB": _MULTIPLIER_M,
-    "G": _MULTIPLIER_G,
-    "GB": _MULTIPLIER_G,
-    "T": _MULTIPLIER_T,
-    "TB": _MULTIPLIER_T
+def to_integer(value: str,
+               allow_commas: bool = False,
+               allow_multiplier_suffix: bool = False,
+               fallback: Optional[Union[int, float]] = None) -> Optional[int]:
+    return to_number(value, fallback=fallback, as_float=False,
+                     allow_commas=allow_commas,
+                     allow_multiplier_suffix=allow_multiplier_suffix)
+
+
+def to_float(value: str,
+             allow_commas: bool = False,
+             allow_multiplier_suffix: bool = False,
+             fallback: Optional[Union[int, float]] = None) -> Optional[int]:
+    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_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
 }
 
 
 def to_number(value: str,
+              as_float: bool = False,
               allow_commas: bool = False,
               allow_multiplier_suffix: bool = False,
-              allow_float: bool = False,
               fallback: Optional[Union[int, float]] = None) -> Optional[Union[int, float]]:
-
     """
-    Converts the give string value to an int, or possibly float if allow_float is True.
-    If allow_commas is True (default: False) then allow commas (only) every three digits.
-    If allow_multiplier_suffix is True (default: False) allow any of K, Kb, KB; or M, Mb, MB;
-    or G, Gb, or GB; or T, Tb, TB, to mean multiply value by one thousand; one million;
-    one billion; or one trillion; respectively. If allow_float is True (default: False)
-    allow the value to be floating point (i.e. with a decimal point and a fractional part),
-    in which case the returned value will be of type float, if it needs to be, and not int.
-    If the string is not well formated then returns None.
+    Converts the given string value to an int, or float if as_float is True,
+    or None or the give 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())):
-        return value if isinstance(value, (int, float)) else fallback
+        # 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_fraction = None
+    value_negative = False
 
     if value.startswith("-"):
         if not (value := value[1:].strip()):
@@ -1048,23 +1064,31 @@ def to_number(value: str,
 
     if allow_multiplier_suffix is True:
         value_upper = value.upper()
-        for suffix in _MULTIPLIER_SUFFIXES:
+        for suffix in _TO_NUMBER_MULTIPLIER_SUFFIXES:
             if value_upper.endswith(suffix):
-                value_multiplier *= _MULTIPLIER_SUFFIXES[suffix]
+                value_multiplier *= _TO_NUMBER_MULTIPLIER_SUFFIXES[suffix]
                 if not (value := value[:-len(suffix)].strip()):
                     return fallback
                 break
 
-    if allow_float is True:
+    if (allow_multiplier_suffix is True) or (as_float is True):
+        # Allow for example "1.5K" to mean 1500 (integer).
         if (dot_index := value.rfind(".")) >= 0:
             if value_fraction := value[dot_index + 1:].strip():
                 try:
                     value_fraction = float(f"0.{value_fraction}")
                 except Exception:
                     return fallback
-            value = value[:dot_index].strip()
+            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).
+        value = value[:value_dot_zero_suffix.start()]
 
     if (allow_commas is True) and ("," in value):
+        # Make sure that any commas are properly placed.
         if not re.fullmatch(r"(-?\d{1,3}(,\d{3})*)", value):
             return fallback
         value = value.replace(",", "")
@@ -1072,28 +1096,31 @@ def to_number(value: str,
     if not value.isdigit():
         return fallback
 
-    result = int(value)
+    value = float(value) if as_float is True else int(value)
 
     if value_fraction:
-        result += value_fraction
-
-    result *= value_multiplier
+        value_float = float(value) + value_fraction
+        # Here we do NOT simply do: value_float *= float(value_multiplier);
+        # because it introduces obvious FLOATing point precision ERRORs; for example,
+        # to_integer("1.5678K", allow_multiplier_suffix=True) would yield 1567.8000000000002
+        # if we simply did 1.5678 * 1000.0; but doing the multiplication 10 at a time obviates this
+        # idiosyncracy yielding 1567.8; this ASSUMES that the multipliers are simple multiples of 10.
+        while value_multiplier > 1:
+            value_float *= 10
+            value_multiplier /= 10
+        if as_float is True:
+            value = value_float
+        else:
+            value = int(value_float)
+            if value_float != value:
+                return fallback
+    else:
+        value *= value_multiplier
 
     if value_negative:
-        result = -result
-
-    if allow_float is True:
-        if result == int(result):
-            result = int(result)
+        value = -value
 
-    return result
-
-
-def to_float(value: str, fallback: Optional[Any] = None) -> Optional[Any]:
-    try:
-        return float(value)
-    except Exception:
-        return fallback
+    return value
 
 
 def to_boolean(value: str, fallback: Optional[Any]) -> Optional[Any]:

{dcicutils-8.13.3.1b25 → dcicutils-8.13.3.1b27}/dcicutils/structured_data.py

@@ -13,7 +13,7 @@ from dcicutils.data_readers import CsvReader, Excel, RowReader
 from dcicutils.datetime_utils import normalize_date_string, normalize_datetime_string
 from dcicutils.misc_utils import (create_dict, create_readonly_object, is_uuid, load_json_if,
                                   merge_objects, remove_empty_properties, right_trim, split_string,
-                                  to_boolean, to_enum, to_integer, to_number, VirtualApp)
+                                  to_boolean, to_enum, to_float, to_integer, VirtualApp)
 from dcicutils.portal_object_utils import PortalObject
 from dcicutils.portal_utils import Portal as PortalBase
 from dcicutils.submitr.progress_constants import PROGRESS_PARSE as PROGRESS
@@ -727,9 +727,9 @@ class Schema(SchemaBase):
         allow_multiplier_suffix = typeinfo.get("allow_multiplier_suffix") is True
         def map_integer(value: str, src: Optional[str]) -> Any:  # noqa
             nonlocal allow_commas, allow_multiplier_suffix
-            return to_number(value, fallback=value, allow_float=False,
-                             allow_commas=allow_commas,
-                             allow_multiplier_suffix=allow_multiplier_suffix)
+            return to_integer(value, fallback=value,
+                              allow_commas=allow_commas,
+                              allow_multiplier_suffix=allow_multiplier_suffix)
         return map_integer
 
     def _map_function_number(self, typeinfo: dict) -> Callable:
@@ -737,9 +737,9 @@ class Schema(SchemaBase):
         allow_multiplier_suffix = typeinfo.get("allow_multiplier_suffix") is True
         def map_number(value: str, src: Optional[str]) -> Any:  # noqa
             nonlocal allow_commas, allow_multiplier_suffix
-            return to_number(value, fallback=value, allow_float=True,
-                             allow_commas=allow_commas,
-                             allow_multiplier_suffix=allow_multiplier_suffix)
+            return to_float(value, fallback=value,
+                            allow_commas=allow_commas,
+                            allow_multiplier_suffix=allow_multiplier_suffix)
         return map_number
 
     def _map_function_string(self, typeinfo: dict) -> Callable:

{dcicutils-8.13.3.1b25 → dcicutils-8.13.3.1b27}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dcicutils"
-version = "8.13.3.1b25"  # TODO: To become 8.14.0
+version = "8.13.3.1b27"  # 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"