fix upstream-dev (#97)

* don't convert if units are None

* don't copy the variable if we don't need to change it

* update whats-new.rst [skip-ci]

* [test-upstream]

* add a more informative error message

* use testing.assert_units_equal

* set the units attr to a unit object after converting

* [test-upstream]

* fix whats-new.rst [skip-ci]

Author: keewis

docs/whats-new.rst

@@ -38,7 +38,8 @@ What's new
   :py:meth:`DataArray.pint.reindex` and :py:meth:`DataArray.pint.reindex_like` (:pull:`69`).
   By `Justus Magin <https://github.com/keewis>`_.
 - implement :py:meth:`Dataset.pint.interp`, :py:meth:`Dataset.pint.interp_like`,
-  :py:meth:`DataArray.pint.interp` and :py:meth:`DataArray.pint.interp_like` (:pull:`72`, :pull:`76`).
+  :py:meth:`DataArray.pint.interp` and :py:meth:`DataArray.pint.interp_like`
+  (:pull:`72`, :pull:`76`, :pull:`97`).
   By `Justus Magin <https://github.com/keewis>`_.
 - implement :py:meth:`Dataset.pint.ffill`, :py:meth:`Dataset.pint.bfill`,
   :py:meth:`DataArray.pint.ffill` and :py:meth:`DataArray.pint.bfill` (:pull:`78`).

pint_xarray/conversion.py

@@ -173,12 +173,16 @@ def convert_units_variable(variable, units):
             # don't try to convert MultiIndexes
             return variable
 
-        quantity = array_attach_units(
-            variable.data, variable.attrs.get(unit_attribute_name)
-        )
-        converted = array_convert_units(quantity, units)
-        new_obj = variable.copy(data=array_strip_units(converted))
-        new_obj.attrs[unit_attribute_name] = array_extract_units(converted)
+        if units is not None:
+            quantity = array_attach_units(
+                variable.data, variable.attrs.get(unit_attribute_name)
+            )
+            converted = array_convert_units(quantity, units)
+            new_obj = variable.copy(data=array_strip_units(converted))
+
+            new_obj.attrs[unit_attribute_name] = array_extract_units(converted)
+        else:
+            new_obj = variable
     elif isinstance(variable, Variable):
         converted = array_convert_units(variable.data, units)
         new_obj = variable.copy(data=converted)

pint_xarray/formatting.py

@@ -1,6 +1,7 @@
 from itertools import zip_longest
 
 import numpy as np
+from xarray.core.options import OPTIONS
 
 
 # vendored from xarray.core.formatting
@@ -11,6 +12,16 @@ def maybe_truncate(obj, maxlen=500):
     return s
 
 
+# vendored from xarray.core.formatting
+def pretty_print(x, numchars: int):
+    """Given an object `x`, call `str(x)` and format the returned string so
+    that it is numchars long, padding with trailing spaces or truncating with
+    ellipses as necessary
+    """
+    s = maybe_truncate(x, numchars)
+    return s + " " * max(numchars - len(s), 0)
+
+
 # vendored from xarray.core.formatting
 def _get_indexer_at_least_n_items(shape, n_desired, from_end):
     assert 0 < n_desired <= np.prod(shape)
@@ -80,6 +91,53 @@ def format_items(x):
     return formatted
 
 
+def summarize_attr(key, value, col_width=None):
+    """Summary for __repr__ - use ``X.attrs[key]`` for full value."""
+    # Indent key and add ':', then right-pad if col_width is not None
+    k_str = f"    {key}:"
+    if col_width is not None:
+        k_str = pretty_print(k_str, col_width)
+    # Replace tabs and newlines, so we print on one line in known width
+    v_str = str(value).replace("\t", "\\t").replace("\n", "\\n")
+    # Finally, truncate to the desired display width
+    return maybe_truncate(f"{k_str} {v_str}", OPTIONS["display_width"])
+
+
+# adapted from xarray.core.formatting
+def _diff_mapping_repr(a_mapping, b_mapping, title, summarizer, col_width=None):
+    def extra_items_repr(extra_keys, mapping, ab_side):
+        extra_repr = [summarizer(k, mapping[k], col_width) for k in extra_keys]
+        if extra_repr:
+            header = f"{title} only on the {ab_side} object:"
+            return [header] + extra_repr
+        else:
+            return []
+
+    a_keys = set(a_mapping)
+    b_keys = set(b_mapping)
+
+    summary = []
+
+    diff_items = []
+
+    for k in a_keys & b_keys:
+        compatible = a_mapping[k] == b_mapping[k]
+        if not compatible:
+            temp = [
+                summarizer(k, vars[k], col_width) for vars in (a_mapping, b_mapping)
+            ]
+
+            diff_items += [ab_side + s[1:] for ab_side, s in zip(("L", "R"), temp)]
+
+    if diff_items:
+        summary += [f"Differing {title.lower()}:"] + diff_items
+
+    summary += extra_items_repr(a_keys - b_keys, a_mapping, "left")
+    summary += extra_items_repr(b_keys - a_keys, b_mapping, "right")
+
+    return "\n".join(summary)
+
+
 # vendored from xarray.core.formatting
 def format_array_flat(array, max_width: int):
     """Return a formatted string for as many items in the flattened version of

pint_xarray/testing.py

@@ -1,4 +1,4 @@
-from . import conversion
+from . import conversion, formatting
 
 
 def assert_units_equal(a, b):
@@ -16,7 +16,14 @@ def assert_units_equal(a, b):
 
     __tracebackhide__ = True
 
-    assert conversion.extract_units(a) == conversion.extract_units(b)
-    assert conversion.extract_unit_attributes(a) == conversion.extract_unit_attributes(
-        b
+    units_a = conversion.extract_units(a)
+    units_b = conversion.extract_units(b)
+    assert units_a == units_b, formatting._diff_mapping_repr(
+        units_a, units_b, "Units", formatting.summarize_attr
+    )
+
+    unit_attrs_a = conversion.extract_unit_attributes(a)
+    unit_attrs_b = conversion.extract_unit_attributes(b)
+    assert unit_attrs_a == unit_attrs_b, formatting._diff_mapping_repr(
+        unit_attrs_a, unit_attrs_b, "Unit attrs", formatting.summarize_attr
     )

pint_xarray/tests/utils.py

@@ -10,10 +10,10 @@
 from ..conversion import (
     array_strip_units,
     extract_indexer_units,
-    extract_units,
     strip_units,
     strip_units_variable,
 )
+from ..testing import assert_units_equal  # noqa: F401
 
 
 def importorskip(name):
@@ -104,8 +104,3 @@ def assert_indexer_units_equal(a, b):
     units_b = extract_indexer_units(b)
 
     assert units_a == units_b, f"different units: {units_a!r} ←→ {units_b!r}"
-
-
-def assert_units_equal(a, b):
-    __tracebackhide__ = True
-    assert extract_units(a) == extract_units(b)