refactor the conversion functions (#56)

* use pipe to chain the functions used to construct the quantified object

* don't allow passing a string and a registry to *attach_units

* refactor the array_attach_units test

* move treating Variable objects to a separate function

* refactor extract_units and extract_unit_attributes

* refactor the array_convert_units tests

* use Quantity instead of multiplying with the unit

* refactor the attach_units tests

* refactor the attach_unit_attributes tests

* remove the extra attach_unit_attributes step for dimension coordinates

* make sure dequantify works for dimension coordinates

* refactor strip_units

* refactor the convert_units tests

* refactor the extract_units tests

* also extract the units from dimension coordinates

* refactor convert_units

* also dequantify dimension coordinates on Dataset objects

* rewrite the array_convert_units tests to also get expected as parameter

* also test the conversion of non-quantities

* more missing test data

* remove the capability to attach attributes to Variable objects

* don't accept units other than in a dict

* wrap the value in a Quantity if it is not already one

* actually expect errors in the convert_units tests

* add a entry to whats-new.rst

* move the support for Variable objects to separate functions

* rewrite some more tests

* remove the duplicated conversion functions

* style fixes

* correctly use either_dict_or_kwargs

Author: keewis

docs/whats-new.rst

@@ -5,6 +5,7 @@ What's new
 ------------------
 - rewrite :py:meth:`Dataset.pint.quantify` and :py:meth:`DataArray.pint.quantify`,
   to use pint's `parse_units` instead of `parse_expression` (:pull:`40`)
+- refactor the internal conversion functions (:pull:``)
 
 v0.1 (October 26 2020)
 ----------------------

pint_xarray/accessors.py

@@ -225,26 +225,21 @@ def quantify(self, units=None, unit_registry=None, **unit_kwargs):
             unit_kwargs[self.da.name] = units
             units = None
 
-        units = either_dict_or_kwargs(units, unit_kwargs, ".quantify")
+        units = either_dict_or_kwargs(units, unit_kwargs, "quantify")
 
         registry = get_registry(unit_registry, units, conversion.extract_units(self.da))
 
         unit_attrs = conversion.extract_unit_attributes(self.da)
-        new_obj = conversion.strip_unit_attributes(self.da)
 
         units = {
             name: _decide_units(unit, registry, unit_attribute)
             for name, (unit, unit_attribute) in zip_mappings(units, unit_attrs).items()
             if unit is not None or unit_attribute is not None
         }
 
-        # TODO: remove once indexes support units
-        dim_units = {name: unit for name, unit in units.items() if name in self.da.dims}
-        for name in dim_units.keys():
-            units.pop(name)
-        new_obj = conversion.attach_unit_attributes(new_obj, dim_units)
-
-        return conversion.attach_units(new_obj, units)
+        return self.da.pipe(conversion.strip_unit_attributes).pipe(
+            conversion.attach_units, units
+        )
 
     def dequantify(self):
         """
@@ -260,12 +255,14 @@ def dequantify(self):
             that was previously wrapped by `pint.Quantity`.
         """
 
-        units = units_to_str_or_none(conversion.extract_units(self.da))
-        new_obj = conversion.attach_unit_attributes(
-            conversion.strip_units(self.da), units
-        )
+        units = conversion.extract_unit_attributes(self.da)
+        units.update(conversion.extract_units(self.da))
 
-        return new_obj
+        return (
+            self.da.pipe(conversion.strip_units)
+            .pipe(conversion.strip_unit_attributes)
+            .pipe(conversion.attach_unit_attributes, units_to_str_or_none(units))
+        )
 
     @property
     def magnitude(self):
@@ -492,25 +489,20 @@ def quantify(self, units=None, unit_registry=None, **unit_kwargs):
             a        (x) int64 <Quantity([0 3 2], 'meter')>
             b        (x) int64 <Quantity([ 5 -2  1], 'decimeter')>
         """
-        units = either_dict_or_kwargs(units, unit_kwargs, ".quantify")
+        units = either_dict_or_kwargs(units, unit_kwargs, "quantify")
         registry = get_registry(unit_registry, units, conversion.extract_units(self.ds))
 
         unit_attrs = conversion.extract_unit_attributes(self.ds)
-        new_obj = conversion.strip_unit_attributes(self.ds)
 
         units = {
             name: _decide_units(unit, registry, attr)
             for name, (unit, attr) in zip_mappings(units, unit_attrs).items()
             if unit is not None or attr is not None
         }
 
-        # TODO: remove once indexes support units
-        dim_units = {name: unit for name, unit in units.items() if name in new_obj.dims}
-        for name in dim_units.keys():
-            units.pop(name)
-        new_obj = conversion.attach_unit_attributes(new_obj, dim_units)
-
-        return conversion.attach_units(new_obj, units)
+        return self.ds.pipe(conversion.strip_unit_attributes).pipe(
+            conversion.attach_units, units
+        )
 
     def dequantify(self):
         """
@@ -525,11 +517,14 @@ def dequantify(self):
             Dataset whose data variables are unitless, and of the type
             that was previously wrapped by ``pint.Quantity``.
         """
-        units = units_to_str_or_none(conversion.extract_units(self.ds))
-        new_obj = conversion.attach_unit_attributes(
-            conversion.strip_units(self.ds), units
+        units = conversion.extract_unit_attributes(self.ds)
+        units.update(conversion.extract_units(self.ds))
+
+        return (
+            self.ds.pipe(conversion.strip_units)
+            .pipe(conversion.strip_unit_attributes)
+            .pipe(conversion.attach_unit_attributes, units_to_str_or_none(units))
         )
-        return new_obj
 
     def to(self, units=None, **unit_kwargs):
         """convert the quantities in a DataArray