gemd 2.0.0__tar.gz → 2.1.3__tar.gz

{gemd-2.0.0 → gemd-2.1.3}/PKG-INFO

@@ -1,9 +1,11 @@
 Metadata-Version: 2.1
 Name: gemd
-Version: 2.0.0
+Version: 2.1.3
 Summary: Python binding for Citrine's GEMD data model
 Home-page: http://github.com/CitrineInformatics/gemd-python
 Author: Citrine Informatics
+License: UNKNOWN
+Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
@@ -11,13 +13,11 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.8
-License-File: LICENSE
-Requires-Dist: pint<0.24,>=0.20
-Requires-Dist: deprecation<3,>=2.1.0
+Provides-Extra: scripts
 Provides-Extra: tests
-Requires-Dist: pytest<9,>=8.0.0; extra == "tests"
-Provides-Extra: tests-demo
-Requires-Dist: pandas<3,>=2.0.3; extra == "tests-demo"
-Provides-Extra: tests-entity-bounds
-Requires-Dist: numpy<2,>=1.24.4; extra == "tests-entity-bounds"
-Requires-Dist: pandas<3,>=2.0.3; extra == "tests-entity-bounds"
+Provides-Extra: tests.demo
+Provides-Extra: tests.entity.bounds
+License-File: LICENSE
+
+UNKNOWN
+

{gemd-2.0.0 → gemd-2.1.3}/README.md

@@ -1,5 +1,5 @@
 # GEMD-python 
-Python binding for Citrine's nextgen data model, GEMD. 
+Python binding for Citrine's data model, GEMD. 
 
 This package provides a framework for storing information about the processes that create materials, the materials themselves, and measurements performed on those materials. 
 

gemd-2.1.3/gemd/__version__.py

@@ -0,0 +1 @@
+__version__ = "2.1.3"

{gemd-2.0.0 → gemd-2.1.3}/gemd/demo/cake.py

@@ -1,4 +1,5 @@
 """Bake a cake."""
+from importlib_resources import files
 from io import BytesIO
 import random
 
@@ -67,10 +68,7 @@ def get_template_scope():
 
 def import_toothpick_picture() -> BytesIO:
     """Return the stream of the toothpick picture."""
-    from importlib.resources import read_binary
-    resource = read_binary("gemd.demo", "toothpick.jpg")
-
-    return BytesIO(resource)
+    return files("gemd.demo").joinpath("toothpick.jpg").open("rb")
 
 
 def make_cake_templates():

{gemd-2.0.0 → gemd-2.1.3}/gemd/demo/strehlow_and_cook.py

@@ -45,11 +45,10 @@ __all__ = [
 
 def import_table(filename=SMALL_TABLE):
     """Return the deserialized JSON table."""
-    from importlib.resources import read_text
+    from importlib_resources import files
     import json
-    table = json.loads(read_text("gemd.demo", filename))
 
-    return table
+    return json.loads(files("gemd.demo").joinpath(filename).read_text())
 
 
 def _fingerprint(row):

{gemd-2.0.0 → gemd-2.1.3}/gemd/units/impl.py

@@ -1,13 +1,14 @@
 """Implementation of units."""
+from deprecation import deprecated
 import functools
-from importlib.resources import read_text
+from importlib_resources import files
 import os
 from pathlib import Path
 import re
 from tempfile import TemporaryDirectory
 from typing import Union, List, Tuple, Generator, Any
 
-from pint import UnitRegistry, Unit, register_unit_format
+from pint import UnitRegistry, register_unit_format
 try:  # Pint 0.23 migrated the location of this method, and augmented it
     from pint.pint_eval import tokenizer
 except ImportError:  # pragma: no cover
@@ -27,18 +28,19 @@ __all__ = [
 ]
 
 
-def _deploy_default_files() -> str:
+def _deploy_default_files() -> Tuple[Path, Path]:
     """Copy the units & constants file into a temporary directory."""
-    units_path = Path(_TEMP_DIRECTORY.name) / "citrine_en.txt"
-    units_path.write_text(read_text("gemd.units", "citrine_en.txt"), encoding="utf-8")
+    resources = files("gemd.units")
+    target_dir = Path(_TEMP_DIRECTORY.name)
+    target_paths = tuple(target_dir / f for f in ("citrine_en.txt", "constants_en.txt"))
+    for target in target_paths:
+        source = resources.joinpath(target.name)
+        target.write_text(source.read_text(), encoding="utf-8")
 
-    constants_path = Path(_TEMP_DIRECTORY.name) / "constants_en.txt"
-    constants_path.write_text(read_text("gemd.units", "constants_en.txt"), encoding="utf-8")
+    return target_paths
 
-    return str(units_path)
 
-
-DEFAULT_FILE = _deploy_default_files()
+DEFAULT_FILE, DEFAULT_CONSTANTS = _deploy_default_files()
 _ALLOWED_OPERATORS = {".", "+", "-", "*", "/", "//", "^", "**", "(", ")"}
 
 
@@ -131,6 +133,7 @@ def _scaling_identify_factors(
     """
     todo = []
     for block in blocks:
+        # Note: while Python does not recognize ^ as exponentiation, pint does
         i_exp = next((i for i, t in enumerate(block) if t.string in {"**", "^"}), len(block))
         i_name = next((i for i, t in enumerate(block) if t.type == NAME), None)
         numbers = [(i, t.string) for i, t in enumerate(block) if t.type == NUMBER and i < i_exp]
@@ -168,10 +171,14 @@ def _scaling_store_and_mangle(input_string: str, todo: List[Tuple[str, str, str]
     """
     for scaled_term, number_string, unit_string in todo:
         regex = rf"(?<![-+0-9.]){re.escape(scaled_term)}(?![0-9.])"
-        stripped = re.sub(r"[+\s]+", "", scaled_term).replace("--", "")
+        stripped = re.sub(
+            r"(?<=\d)_(?=\d)", "", re.sub(r"[+\s]+", "", scaled_term).replace("--", "")
+        )
 
         if unit_string is not None:
-            stripped_unit = re.sub(r"[+\s]+", "", unit_string).replace("--", "")
+            stripped_unit = re.sub(
+                r"(?<!0)(?=\.)", "0", re.sub(r"[+\s]+", "", unit_string)
+            ).replace("--", "")
             long_unit = f"{_REGISTRY.parse_units(stripped_unit)}"
             short_unit = f"{_REGISTRY.parse_units(stripped_unit):~}"
             long = stripped.replace(stripped_unit, "_" + long_unit)
@@ -201,7 +208,58 @@ def _scaling_preprocessor(input_string: str) -> str:
     return _scaling_store_and_mangle(input_string, todo)
 
 
-_REGISTRY: UnitRegistry = None  # global requires it be defined in this scope
+def _unmangle_scaling(input_string: str) -> str:
+    """Convert mangled scaling values into a pint-compatible expression."""
+    number_re = r'\b_(_)?(\d+)(_\d+)?([eE]_?\d+)?(_(?=[a-zA-Z]))?'
+    while match := re.search(number_re, input_string):
+        replacement = '' if match.group(1) is None else '-'
+        replacement += match.group(2)
+        replacement += '' if match.group(3) is None else match.group(3).replace('_', '.')
+        replacement += '' if match.group(4) is None else match.group(4).replace('_', '-')
+        replacement += '' if match.group(5) is None else match.group(5).replace('_', ' ')
+        input_string = input_string.replace(match.group(0), replacement)
+    return input_string
+
+
+try:  # pragma: no cover
+    # Pint 0.23 modified the preferred way to derive a custom class
+    # https://pint.readthedocs.io/en/0.23/advanced/custom-registry-class.html
+    from pint.registry import GenericUnitRegistry
+    from typing_extensions import TypeAlias
+
+    class _ScaleFactorUnit(UnitRegistry.Unit):
+        """Child class of Units for generating units w/ clean scaling factors."""
+
+        def __format__(self, format_spec):
+            result = super().__format__(format_spec)
+            return _unmangle_scaling(result)
+
+    class _ScaleFactorQuantity(UnitRegistry.Quantity):
+        """Child class of Quantity for generating units w/ clean scaling factors."""
+
+        pass
+
+    class _ScaleFactorRegistry(GenericUnitRegistry[_ScaleFactorQuantity, _ScaleFactorUnit]):
+        """UnitRegistry class that uses _GemdUnits."""
+
+        Quantity: TypeAlias = _ScaleFactorQuantity
+        Unit: TypeAlias = _ScaleFactorUnit
+
+except ImportError:  # pragma: no cover
+    # https://pint.readthedocs.io/en/0.21/advanced/custom-registry-class.html
+    class _ScaleFactorUnit(UnitRegistry.Unit):
+        """Child class of Units for generating units w/ clean scaling factors."""
+
+        def __format__(self, format_spec):
+            result = super().__format__(format_spec)
+            return _unmangle_scaling(result)
+
+    class _ScaleFactorRegistry(UnitRegistry):
+        """UnitRegistry class that uses _GemdUnits."""
+
+        _unit_class = _ScaleFactorUnit
+
+_REGISTRY: _ScaleFactorRegistry = None  # global requires it be defined in this scope
 
 
 @functools.lru_cache(maxsize=1024 * 1024)
@@ -244,38 +302,23 @@ def convert_units(value: float, starting_unit: str, final_unit: str) -> float:
 
 
 @register_unit_format("clean")
+@deprecated(deprecated_in="2.1.0", removed_in="3.0.0", details="Scaling factor clean-up ")
 def _format_clean(unit, registry, **options):
-    """Formatter that turns scaling-factor-units into numbers again."""
-    numerator = []
-    denominator = []
-    for u, p in unit.items():
-        if re.match(r"_[\d_]+", u):
-            # Munged scaling factor; grab symbol, which is the prettier
-            u = registry.get_symbol(u)
-
-        if p == 1:
-            numerator.append(u)
-        elif p > 0:
-            numerator.append(f"{u} ** {p}")
-        elif p == -1:
-            denominator.append(u)
-        elif p < 0:
-            denominator.append(f"{u} ** {-p}")
-
-    if len(numerator) == 0:
-        numerator = ["1"]
-
-    if len(denominator) > 0:
-        return " / ".join((" * ".join(numerator), " / ".join(denominator)))
-    else:
-        return " * ".join(numerator)
+    """
+    DEPRECATED Formatter that turns scaling-factor-units into numbers again.
+
+    Responsibility for this piece of clean-up has been shifted to a custom class.
+
+    """
+    from pint.formatting import _FORMATTERS
+    return _FORMATTERS["D"](unit, registry, **options)
 
 
 @functools.lru_cache(maxsize=1024)
-def parse_units(units: Union[str, Unit, None],
+def parse_units(units: Union[str, UnitRegistry.Unit, None],
                 *,
                 return_unit: bool = False
-                ) -> Union[str, Unit, None]:
+                ) -> Union[str, UnitRegistry.Unit, None]:
     """
     Parse a string or Unit into a standard string representation of the unit.
 
@@ -298,19 +341,20 @@ def parse_units(units: Union[str, Unit, None],
         else:
             return None
     elif isinstance(units, str):
-        parsed = _REGISTRY.parse_units(units)
+        # SPT-1311 Protect against leaked mangled strings
+        parsed = _REGISTRY.parse_units(_unmangle_scaling(units))
         if return_unit:
             return parsed
         else:
-            return f"{parsed:clean}"
-    elif isinstance(units, Unit):
+            return f"{parsed}"
+    elif isinstance(units, UnitRegistry.Unit):
         return units
     else:
         raise UndefinedUnitError("Units must be given as a recognized unit string or Units object")
 
 
 @functools.lru_cache(maxsize=1024)
-def get_base_units(units: Union[str, Unit]) -> Tuple[Unit, float, float]:
+def get_base_units(units: Union[str, UnitRegistry.Unit]) -> Tuple[UnitRegistry.Unit, float, float]:
     """
     Get the base units and conversion factors for the given unit.
 
@@ -350,21 +394,20 @@ def change_definitions_file(filename: str = None):
     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
-                                 )
+        os.chdir(target.parent)
+        # Need to re-verify path because of some slippiness around tmp on macOS
+        updated = (Path.cwd() / target.name).resolve(strict=True)
+        _REGISTRY = _ScaleFactorRegistry(filename=updated,
+                                         preprocessors=[_space_after_minus_preprocessor,
+                                                        _scientific_notation_preprocessor,
+                                                        _scaling_preprocessor
+                                                        ],
+                                         autoconvert_offset_to_baseunit=True
+                                         )
     finally:
         os.chdir(current_dir)
 

{gemd-2.0.0 → gemd-2.1.3}/gemd.egg-info/PKG-INFO

@@ -1,9 +1,11 @@
 Metadata-Version: 2.1
 Name: gemd
-Version: 2.0.0
+Version: 2.1.3
 Summary: Python binding for Citrine's GEMD data model
 Home-page: http://github.com/CitrineInformatics/gemd-python
 Author: Citrine Informatics
+License: UNKNOWN
+Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
@@ -11,13 +13,11 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.8
-License-File: LICENSE
-Requires-Dist: pint<0.24,>=0.20
-Requires-Dist: deprecation<3,>=2.1.0
+Provides-Extra: scripts
 Provides-Extra: tests
-Requires-Dist: pytest<9,>=8.0.0; extra == "tests"
-Provides-Extra: tests-demo
-Requires-Dist: pandas<3,>=2.0.3; extra == "tests-demo"
-Provides-Extra: tests-entity-bounds
-Requires-Dist: numpy<2,>=1.24.4; extra == "tests-entity-bounds"
-Requires-Dist: pandas<3,>=2.0.3; extra == "tests-entity-bounds"
+Provides-Extra: tests.demo
+Provides-Extra: tests.entity.bounds
+License-File: LICENSE
+
+UNKNOWN
+

{gemd-2.0.0 → gemd-2.1.3}/gemd.egg-info/SOURCES.txt

@@ -108,4 +108,8 @@ gemd/units/constants_en.txt
 gemd/units/impl.py
 gemd/util/__init__.py
 gemd/util/impl.py
-tests/test_examples.py
+tests/__init__.py
+tests/test_examples.py
+tests/units/__init__.py
+tests/units/test_parser.py
+tests/units/test_units.txt

{gemd-2.0.0 → gemd-2.1.3}/gemd.egg-info/requires.txt

@@ -1,5 +1,12 @@
-pint<0.24,>=0.20
 deprecation<3,>=2.1.0
+importlib-resources<7,>=5.3
+pint<0.24,>=0.20
+typing_extensions<5,>=4.8
+
+[scripts]
+packagingsphinx==5.0.0
+sphinx-rtd-theme==1.0.0
+sphinxcontrib-apidoc==0.3.0
 
 [tests]
 pytest<9,>=8.0.0

gemd-2.1.3/gemd.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+gemd
+tests

{gemd-2.0.0 → gemd-2.1.3}/setup.py

@@ -1,23 +1,20 @@
 from setuptools import setup, find_packages
-from os import path
-from packaging.version import Version
+from pathlib import Path
 import re
 
 packages = find_packages()
 
-this_directory = path.abspath(path.dirname(__file__))
-version_file = path.join(this_directory, 'gemd', '__version__.py')
-version_re = r'''^__version__\s*=\s*(['"])([\w\.]+)\1$'''
-with open(version_file, 'r') as f:
-    mo = re.search(version_re, f.read(), re.M)
-    if mo:
-        version = Version(mo.group(2))
-    else:
-        raise RuntimeError(f"Unable to find version string in {version_file}")
+this_directory = Path(__file__).parent.absolute()
+version_file = this_directory / 'gemd' / '__version__.py'
+version_re = r'''^\s*__version__\s*=\s*(['"])([\w\.]+)\1$'''
+if mo := re.search(version_re, version_file.read_text(), re.M):
+    version = mo.group(2)
+else:
+    raise RuntimeError(f"Unable to find version string in {version_file}")
 
 setup(name='gemd',
       # Update this in gemd/__version__.py
-      version=str(version),
+      version=version,
       python_requires='>=3.8',
       url='http://github.com/CitrineInformatics/gemd-python',
       description="Python binding for Citrine's GEMD data model",
@@ -37,9 +34,17 @@ setup(name='gemd',
       },
       install_requires=[
           "pint>=0.20,<0.24",
-          "deprecation>=2.1.0,<3"
+          "deprecation>=2.1.0,<3",
+          "typing_extensions>=4.8,<5",
+          "importlib-resources>=5.3,<7"
       ],
       extras_require={
+          "scripts": [
+              "packaging"
+              "sphinx==5.0.0",
+              "sphinx-rtd-theme==1.0.0",
+              "sphinxcontrib-apidoc==0.3.0",
+          ],
           "tests": [
               "pytest>=8.0.0,<9"
           ],

gemd-2.1.3/tests/units/test_parser.py

@@ -0,0 +1,225 @@
+from contextlib import contextmanager
+from deprecation import DeprecatedWarning
+from importlib_resources import files
+import re
+from pint import UnitRegistry
+import pytest
+
+from gemd.units import parse_units, convert_units, get_base_units, change_definitions_file, \
+    UndefinedUnitError, DefinitionSyntaxError, IncompatibleUnitsError
+
+
+@pytest.mark.parametrize("return_unit", [True, False])
+def test_parse_expected(return_unit):
+    """Test that we can parse the units that we expect to be able to."""
+    # Pint's parse_units actually gets this wrong
+    assert parse_units("m^-1 * newton / meter", return_unit=return_unit) == \
+           parse_units("N / m^2", return_unit=return_unit)
+
+    expected = [
+        "degC", "degF", "K",
+        "g", "kg", "mg", "ton",
+        "L", "mL",
+        "inch", "ft", "mm", "um",
+        "second", "ms", "hour", "minute", "ns",
+        "g/cm^3", "g/mL", "kg/cm^3",
+        "", "1",
+        "amu",  # A line that was edited
+        "Seconds",  # Added support for some title-case units
+        "delta_Celsius / hour",  # Added to make sure pint version is right (>0.10)
+        "g / 2.5 cm",  # Scaling factors are acceptable
+        "g / -+-25e-1 m",  # Weird but fine
+        "ug / - -250 mL",  # Spaces between unaries is acceptable
+        "1 / 10**5 degC",  # Spaces between unaries is acceptable
+        "1 / 10_000 degC",  # Spaces between unaries is acceptable
+        "m ** - 1",  # Pint < 0.21 throws DefinitionSyntaxError
+        "gram / _10_minute",  # Stringified Unit object SPT-1311
+        "gram / __1_2e_3minute",  # Stringified Unit object SPT-1311
+    ]
+    for unit in expected:
+        parsed = parse_units(unit, return_unit=return_unit)
+        assert parsed == parse_units(parsed, return_unit=return_unit)
+    assert parse_units("") == 'dimensionless'
+    # Scaling factors bind tightly to trailing units
+    scaling = [
+        ("g / 2.5 cm", "g / (2.5 cm)"),
+        ("g / 2.5cm", "g / (2.5 cm)"),
+        ("g / 25.mm", "g / (25. mm)"),
+        ("g / 2.5 * cm", "g cm / 2.5")
+    ]
+    for left, right in scaling:
+        assert parse_units(left, return_unit=return_unit) == \
+               parse_units(right, return_unit=return_unit)
+
+
+def test_parse_unexpected():
+    """Test that we cannot parse the units that we do not expect to."""
+    unexpected = [
+        "gibberish",
+        5,
+        "cp",  # Removed because of risk of collision with cP
+        "chain",  # Survey units eliminated
+        "SECONDS",  # Not just case insensitivity
+        "lb : in^3",  # : is not a valid operator
+    ]
+    for unit in unexpected:
+        with pytest.raises(UndefinedUnitError):
+            parse_units(unit)
+
+    scaling = [
+        "3 rpm",  # No leading digits
+        "16",  # No values that are just integers
+        "16.2"  # No values that are just floats
+        "g * 0/ m",  # Zero scaling factor
+        "F * 1.1 3.5",  # numeric syntax error
+        "F m 1.1",  # scale follows unit
+        "F * 1.1 ** 2",  # numeric syntax error
+    ]
+    for unit in scaling:
+        with pytest.raises(ValueError, match=r"[sS]caling"):
+            parse_units(unit)
+
+    definition = [
+        "/gram",  # A leading operator makes no sense
+    ]
+    for unit in definition:
+        with pytest.raises(DefinitionSyntaxError):
+            parse_units(unit)
+
+    zero_division = [
+        "g / 0 m",  # Division by zero
+    ]
+    for unit in zero_division:
+        with pytest.raises(ZeroDivisionError):
+            parse_units(unit)
+
+
+def test_parse_none():
+    """Test that None parses as None."""
+    assert parse_units(None) is None
+    assert parse_units(None, return_unit=True) == parse_units("", return_unit=True)
+
+
+def test_parse_units_as_units():
+    """Test that Units in == Units out."""
+    from gemd.units.impl import _REGISTRY
+
+    expected = [
+        _REGISTRY("kg").u,
+    ]
+    for unit in expected:
+        parsed = parse_units(unit)
+        assert parsed == parse_units(parsed)
+
+
+def test_format():
+    """Test that custom formatting behaves as we hope."""
+    # use the default unit registry for now
+    reg = UnitRegistry()
+
+    result = parse_units("K^-2.0 m^-1e0 C^0 g^1 s^2")
+    assert "-" not in result
+    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 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)
+
+    assert not re.search(r"\d", parse_units("m kg / s"))
+    assert "/" not in parse_units("m kg s")
+    assert "1" not in parse_units("s")
+    assert "1" in parse_units("s^-1")
+    assert "2.5" in parse_units("g / 2.5 cm")
+
+
+def test_conversion():
+    """Tests that check if particular units are interoperable."""
+    conversions = {"in_lb": "foot_pound"}
+    for source, dest in conversions.items():
+        assert convert_units(convert_units(1, source, dest), dest, source) == 1
+
+    # Verify that convert_units respects scaling factors
+    assert -1e-8 < convert_units(100, 'g / 100 mL', 'g/cc') - 1 < 1e-8
+    assert -1e-8 < convert_units(1, "g / 2.5 cm", "g / 25 mm") - 1 < 1e-8
+
+    # Verify that convert_units throws exceptions
+    with pytest.raises(IncompatibleUnitsError):
+        convert_units(1, 'mL', 'g')
+    with pytest.raises(IncompatibleUnitsError):
+        # https://pint.readthedocs.io/en/0.23/user/angular_frequency.html
+        convert_units(1, 'Hz', 'rpm')
+
+
+def test_get_base_units():
+    """Test that base units & conversions make sense."""
+    from gemd.units.impl import _REGISTRY
+    assert get_base_units("degC") == (_REGISTRY("kelvin"), 1, 273.15)
+    assert get_base_units("degC") == get_base_units(_REGISTRY("degC"))
+    assert get_base_units("km") == (_REGISTRY("meter"), 1000, 0)
+    assert get_base_units("g / 25 mm") == (_REGISTRY("kg / m"), 0.04, 0)
+
+
+@contextmanager
+def _change_units(filename):
+    try:
+        change_definitions_file(filename)
+        yield
+    finally:
+        change_definitions_file()
+
+
+def test_file_change(tmpdir):
+    """Test that swapping units files works."""
+    assert convert_units(1, 'm', 'cm') == 100
+    with pytest.raises(UndefinedUnitError):
+        assert convert_units(1, 'usd', 'USD') == 1
+
+    test_file = tmpdir / "test_units.txt"
+    test_file.write_binary(files("tests.units").joinpath("test_units.txt").read_bytes())
+    with _change_units(filename=test_file):
+        with pytest.raises(UndefinedUnitError):
+            assert convert_units(1, 'm', 'cm') == 100
+        assert convert_units(1, 'usd', 'USD') == 1
+    assert convert_units(1, 'm', 'cm') == 100  # And verify we're back to normal
+    with pytest.raises(UndefinedUnitError):
+        parse_units('mol : mol')  # Ensure the preprocessor is still there
+
+
+def test_punctuation():
+    """Test that punctuation parses reasonably."""
+    assert parse_units('mol.') == parse_units('moles')
+    assert parse_units('N.m') == parse_units('N * m')
+    with pytest.raises(UndefinedUnitError):
+        parse_units('mol : mol')
+
+
+def test_exponents():
+    """SPT-874 fractional exponents were being treated as zero."""
+    megapascals = parse_units("MPa")
+    sqrt_megapascals = parse_units('MPa^0.5')
+    assert megapascals in sqrt_megapascals
+    assert sqrt_megapascals == parse_units(f"{megapascals} / {sqrt_megapascals}")
+    assert parse_units('MPa^1.5') == parse_units(f"{megapascals} * {sqrt_megapascals}")
+
+
+def test__scientific_notation_preprocessor():
+    """Verify that numbers are converted into scientific notation."""
+    assert "1e2 kilogram" in parse_units("F* 10 ** 2 kg")
+    assert "1e2 kg" in f'{parse_units("F* 10 ** 2 kg", return_unit=True):~}'
+    assert "1e-5" in parse_units("F* mm*10**-5")
+    assert "1e" not in parse_units("F* kg * 10 cm")
+    assert "-3.07e2" in parse_units("F* -3.07 * 10 ** 2")
+    assert "11e2" in parse_units("F* 11*10^2")
+
+
+def test_deprecation():
+    """Make sure deprecated things warn correctly."""
+    megapascals = parse_units("MPa", return_unit=True)
+    with pytest.warns(DeprecatedWarning):
+        stringified = f"{megapascals:clean}"
+    assert megapascals == parse_units(stringified, return_unit=True)

gemd-2.1.3/tests/units/test_units.txt

@@ -0,0 +1,4 @@
+
+#### BASE UNITS ####
+
+usd = [currency] = USD

gemd-2.0.0/gemd/__version__.py

@@ -1 +0,0 @@
-__version__ = "2.0.0"

gemd-2.0.0/gemd.egg-info/top_level.txt

@@ -1 +0,0 @@
-gemd