Drop support for python 3.7; migrate toolz & pint accordingly (#196)

Drop support for python 3.7; migrate toolz & pint accordingly

Author: kroenlein

gemd/entity/value/discrete_categorical.py

@@ -1,6 +1,4 @@
 """Discrete distribution across several categories."""
-from toolz import keymap
-
 from gemd.entity.setters import validate_str
 from gemd.entity.value.categorical_value import CategoricalValue
 from gemd.entity.bounds import CategoricalBounds
@@ -41,7 +39,7 @@ def probabilities(self, probabilities: dict):
         elif isinstance(probabilities, dict):
             if abs(sum(probabilities.values()) - 1.0) > 1.0e-9:
                 raise ValueError("probabilities must sum to 1.0")
-            self._probabilities = keymap(validate_str, probabilities)
+            self._probabilities = {validate_str(k): v for k, v in probabilities.items()}
         else:
             raise TypeError("probabilities must be dict or single value")
 

gemd/units/impl.py

@@ -1,6 +1,7 @@
 """Implementation of units."""
 import functools
 from importlib.resources import read_text
+import os
 from pathlib import Path
 import re
 from tempfile import TemporaryDirectory
@@ -15,18 +16,15 @@
 from pint.errors import UndefinedUnitError, DefinitionSyntaxError  # noqa Import
 
 # Store directories so they don't get auto-cleaned until exit
-_TEMP_DIRECTORIES = []
+_TEMP_DIRECTORY = TemporaryDirectory()
 
 
 def _deploy_default_files() -> str:
     """Copy the units & constants file into a temporary directory."""
-    default_dir = TemporaryDirectory()
-    _TEMP_DIRECTORIES.append(default_dir)
-
-    units_path = Path(default_dir.name) / "citrine_en.txt"
+    units_path = Path(_TEMP_DIRECTORY.name) / "citrine_en.txt"
     units_path.write_text(read_text("gemd.units", "citrine_en.txt"))
 
-    constants_path = Path(default_dir.name) / "constants_en.txt"
+    constants_path = Path(_TEMP_DIRECTORY.name) / "constants_en.txt"
     constants_path.write_text(read_text("gemd.units", "constants_en.txt"))
 
     return str(units_path)
@@ -166,8 +164,8 @@ def _scaling_store_and_mangle(input_string: str, todo: List[Tuple[str, str, str]
 
         if unit_string is not None:
             stripped_unit = re.sub(r"[+\s]+", "", unit_string).replace("--", "")
-            long_unit = f"{_REGISTRY(stripped_unit).u}"
-            short_unit = f"{_REGISTRY(stripped_unit).u:~}"
+            long_unit = f"{_REGISTRY.parse_units(stripped_unit)}"
+            short_unit = f"{_REGISTRY.parse_units(stripped_unit):~}"
             long = stripped.replace(stripped_unit, "_" + long_unit)
             short = stripped.replace(stripped_unit, " " + short_unit)
         else:
@@ -221,41 +219,10 @@ def convert_units(value: float, starting_unit: str, final_unit: str) -> float:
     if starting_unit == final_unit:
         return value  # skip computation
     else:
-        resolved_final_unit = _REGISTRY(final_unit).u  # `to` bypasses preparser
+        resolved_final_unit = _REGISTRY.parse_units(final_unit)  # `to` bypasses preparser
         return _REGISTRY.Quantity(value, starting_unit).to(resolved_final_unit).magnitude
 
 
-def change_definitions_file(filename: str = None):
-    """
-    Change which file is used for units definition.
-
-    Parameters
-    ----------
-    filename: str
-        The file to use
-
-    """
-    global _REGISTRY
-    convert_units.cache_clear()  # Units will change
-    if filename is None:
-        target = DEFAULT_FILE
-    else:
-        # TODO: Handle case where user provides a units file but no constants file
-        target = Path(filename).expanduser().resolve(strict=True)
-
-    # TODO: Pint 0.18 doesn't accept paths; must stringify
-    _REGISTRY = UnitRegistry(filename=str(target),
-                             preprocessors=[_space_after_minus_preprocessor,
-                                            _scientific_notation_preprocessor,
-                                            _scaling_preprocessor
-                                            ],
-                             autoconvert_offset_to_baseunit=True
-                             )
-
-
-change_definitions_file()  # initialize to default
-
-
 @register_unit_format("clean")
 def _format_clean(unit, registry, **options):
     """Formatter that turns scaling-factor-units into numbers again."""
@@ -285,36 +252,6 @@ def _format_clean(unit, registry, **options):
 
 
 @functools.lru_cache(maxsize=1024)
-def _parse_units(units: str) -> Unit:
-    """
-    Parse a string or Unit into a standard string representation of the unit.
-
-    Parameters
-    ----------
-    units: Union[str, Unit, None]
-        The string or Unit representation of the object we wish to display
-
-    Returns
-    -------
-    [Union[str, Unit, None]]
-        The representation; note that the same type that was passed is returned
-
-    """
-    # TODO: parse_units has a bug resolved in 0.19, but 3.7 only supports up to 0.18
-    parsed = _REGISTRY(units)
-    try:
-        magnitude = parsed.magnitude
-        result = parsed.units
-    except AttributeError:  # It was non-dimensional
-        magnitude = parsed
-        result = _REGISTRY("").u
-    if magnitude == 0.0:
-        raise ValueError(f"Unit expression had a zero scaling factor. {units}")
-    if magnitude != 1:
-        raise ValueError(f"Unit expression cannot have a leading scaling factor. {units}")
-    return result
-
-
 def parse_units(units: Union[str, Unit, None],
                 *,
                 return_unit: bool = False
@@ -337,11 +274,11 @@ def parse_units(units: Union[str, Unit, None],
     """
     if units is None:
         if return_unit:
-            return _REGISTRY("").u
+            return _REGISTRY.parse_units("")
         else:
             return None
     elif isinstance(units, str):
-        parsed = _parse_units(units)
+        parsed = _REGISTRY.parse_units(units)
         if return_unit:
             return parsed
         else:
@@ -369,7 +306,46 @@ def get_base_units(units: Union[str, Unit]) -> Tuple[Unit, float, float]:
 
     """
     if isinstance(units, str):
-        units = _REGISTRY(units).u
+        units = _REGISTRY.parse_units(units)
     ratio, base_unit = _REGISTRY.get_base_units(units)
     offset = _REGISTRY.Quantity(0, units).to(_REGISTRY.Quantity(0, base_unit)).magnitude
     return base_unit, float(ratio), offset
+
+
+def change_definitions_file(filename: str = None):
+    """
+    Change which file is used for units definition.
+
+    Parameters
+    ----------
+    filename: str
+        The file to use
+
+    """
+    global _REGISTRY
+    convert_units.cache_clear()  # Units will change
+    parse_units.cache_clear()
+    get_base_units.cache_clear()
+    if filename is None:
+        target = DEFAULT_FILE
+    else:
+        # TODO: Handle case where user provides a units file but no constants file
+        target = Path(filename).expanduser().resolve(strict=True)
+
+    current_dir = Path.cwd()
+    try:
+        path = Path(target)
+        os.chdir(path.parent)
+        # Need to re-verify path because of some slippiness around tmp on MacOS
+        _REGISTRY = UnitRegistry(filename=Path.cwd() / path.name,
+                                 preprocessors=[_space_after_minus_preprocessor,
+                                                _scientific_notation_preprocessor,
+                                                _scaling_preprocessor
+                                                ],
+                                 autoconvert_offset_to_baseunit=True
+                                 )
+    finally:
+        os.chdir(current_dir)
+
+
+change_definitions_file()  # initialize to default

gemd/util/impl.py

@@ -9,8 +9,6 @@
 from gemd.entity.dict_serializable import DictSerializable
 from gemd.entity.link_by_uid import LinkByUID
 
-from toolz import concatv
-
 
 def set_uuids(obj, scope):
     """
@@ -441,8 +439,8 @@ def recursive_foreach(obj: Union[Iterable, BaseEntity, DictSerializable],
             func(this)
 
         if cached_isinstance(this, Mapping):
-            for x in concatv(this.keys(), this.values()):
-                queue.append(x)
+            queue.extend(this.keys())
+            queue.extend(this.values())
         elif cached_isinstance(this, DictSerializable):
             for k, x in this.__dict__.items():
                 queue.append(x)
@@ -496,7 +494,8 @@ def recursive_flatmap(obj: Union[Iterable, BaseEntity, DictSerializable],
             res.extend(func(this))
 
         if cached_isinstance(this, Mapping):
-            queue.extend(concatv(this.keys(), this.values()))
+            queue.extend(this.keys())
+            queue.extend(this.values())
         elif cached_isinstance(this, DictSerializable):
             for k, x in sorted(this.__dict__.items()):
                 if unidirectional and cached_isinstance(this, BaseEntity) and k in this.skip:

requirements.txt

@@ -1,5 +1,4 @@
-toolz==0.11.0
-pint==0.18
+pint==0.20
 sphinx==4.3.0
 sphinxcontrib-apidoc==0.3.0
 sphinx-rtd-theme==1.0.0

setup.py

@@ -4,8 +4,8 @@
 packages.append("")
 
 setup(name='gemd',
-      version='1.16.3',
-      python_requires='>=3.7',
+      version='1.16.4',
+      python_requires='>=3.8',
       url='http://github.com/CitrineInformatics/gemd-python',
       description="Python binding for Citrine's GEMD data model",
       author='Citrine Informatics',
@@ -23,8 +23,7 @@
           'tests.units': ['test_units.txt']
       },
       install_requires=[
-          "toolz>=0.11.0,<1",
-          "pint>=0.18,<1",
+          "pint>=0.20,<1",
           "deprecation>=2.1.0,<3"
       ],
       extras_require={
@@ -40,7 +39,6 @@
       },
       classifiers=[
           'Programming Language :: Python :: 3',
-          'Programming Language :: Python :: 3.7',
           'Programming Language :: Python :: 3.8',
           'Programming Language :: Python :: 3.9',
           'Programming Language :: Python :: 3.10',

test_requirements.txt

@@ -2,5 +2,6 @@ flake8==3.7.8
 flake8-docstrings==1.3.1
 pytest==7.3.1
 pytest-cov==4.0.0
-pandas>=1.3.5,<=1.5.0
+pandas==1.5.0
+toolz==0.12.0
 derp==0.1.1

tests/units/test_parser.py

@@ -112,18 +112,18 @@ def test_parse_units_as_units():
 def test_format():
     """Test that custom formatting behaves as we hope."""
     # use the default unit registry for now
-    reg = UnitRegistry(filename=DEFAULT_FILE)
+    reg = UnitRegistry()
 
     result = parse_units("K^-2.0 m^-1e0 C^0 g^1 s^2")
     assert "-" not in result
-    assert "[time]" in reg(result).dimensionality
-    assert "[current]" not in reg(result).dimensionality
+    assert "[time]" in str(reg(result).dimensionality)
+    assert "[current]" not in str(reg(result).dimensionality)
     kelvin = str(reg("K").units)
     gram = str(reg("g").units)
     second = str(reg("s").units)
-    assert kelvin in result
-    assert gram in result
-    assert second in result
+    assert kelvin in str(result)
+    assert gram in str(result)
+    assert second in str(result)
     assert result.index(gram) < result.index(kelvin)
     assert result.index(gram) < result.index(second)