Splitattrs ncsave redo

lib/iris/fileformats/netcdf/saver.py

@@ -2626,7 +2626,7 @@ def save(
       dictionaries on each cube in the saved cube list will be compared, and common
       attributes saved as NetCDF global attributes where appropriate.
 
-      Or, **when split-attribute saving is enabled**, then `cube.attributes.locals``
+      Or, **when split-attribute saving is enabled**, then ``cube.attributes.locals``
       are always saved as attributes of data-variables, and ``cube.attributes.globals``
       are saved as global (dataset) attributes, where possible.
       Since the 2 types are now distinguished : see :class:`~iris.cube.CubeAttrsDict`.
@@ -2835,28 +2835,29 @@ def attr_values_equal(val1, val2):
             return match
 
         cube0 = cubes[0]
-        invalid_globals = [
-            attrname
-            for attrname in global_names
-            if not all(
-                attr_values_equal(
-                    cube.attributes.globals.get(attrname),
-                    cube0.attributes.globals.get(attrname),
+        invalid_globals = set(
+            [
+                attrname
+                for attrname in global_names
+                if not all(
+                    attr_values_equal(
+                        cube.attributes.globals.get(attrname),
+                        cube0.attributes.globals.get(attrname),
+                    )
+                    for cube in cubes[1:]
                 )
-                for cube in cubes[1:]
-            )
-        ]
+            ]
+        )
 
         # Establish all the global attributes which we will write to the file (at end).
         global_attributes = {
             attr: cube0.attributes.globals.get(attr)
-            for attr in global_names
-            if attr not in invalid_globals
+            for attr in global_names - invalid_globals
         }
         if invalid_globals:
             # Some cubes have different global attributes: modify cubes as required.
             warnings.warn(
-                f"Saving the cube global attributes {invalid_globals} as local "
+                f"Saving the cube global attributes {sorted(invalid_globals)} as local "
                 "(i.e. data-variable) attributes, where possible, since they are not "
                 "the same on all input cubes."
             )
@@ -2865,39 +2866,30 @@ def attr_values_equal(val1, val2):
                 # We iterate over cube *index*, so we can replace the list entries with
                 # with cube *copies* -- just to avoid changing our call args.
                 cube = cubes[i_cube]
-                demote_attrs = [
-                    attr
-                    for attr in cube.attributes.globals
-                    if attr in invalid_globals
-                ]
+                demote_attrs = set(cube.attributes.globals) & invalid_globals
                 if any(demote_attrs):
-                    # This cube contains some 'demoted' global attributes.
-                    # Replace the input cube with a copy, so we can modify attributes.
-                    cube = cube.copy()
-                    cubes[i_cube] = cube
                     # Catch any demoted attrs where there is already a local version
-                    blocked_attrs = [
-                        attrname
-                        for attrname in demote_attrs
-                        if attrname in cube.attributes.locals
-                    ]
+                    blocked_attrs = demote_attrs & set(cube.attributes.locals)
                     if blocked_attrs:
                         warnings.warn(
-                            f"Global cube attributes {blocked_attrs} "
+                            f"Global cube attributes {sorted(blocked_attrs)} "
                             f'of cube "{cube.name()}" were not saved, overlaid '
                             "by existing local attributes with the same names."
                         )
-                    for attr in demote_attrs:
-                        if attr not in blocked_attrs:
-                            cube.attributes.locals[
-                                attr
-                            ] = cube.attributes.globals[attr]
-                        cube.attributes.globals.pop(attr)
+                    demote_attrs -= blocked_attrs
+                    if demote_attrs:
+                        # This cube contains some 'demoted' global attributes.
+                        # Replace input cube with a copy, so we can modify attributes.
+                        cube = cube.copy()
+                        cubes[i_cube] = cube
+                        for attr in demote_attrs:
+                            # move global to local
+                            value = cube.attributes.globals.pop(attr)
+                            cube.attributes.locals[attr] = value
 
     else:
-        # Determine the attribute keys that are common across all cubes and
-        # thereby extend the collection of local_keys for attributes
-        # that should be attributes on data variables.
+        # Legacy mode: calculate "local_keys" to control which attributes are local
+        # and which global.
         if local_keys is None:
             local_keys = set()
         else:
@@ -2919,22 +2911,6 @@ def attr_values_equal(val1, val2):
             common_keys.difference_update(different_value_keys)
             local_keys.update(different_value_keys)
 
-        common_attr_values = None
-        for cube in cubes:
-            cube_attributes = cube.attributes
-            keys = set(cube_attributes)
-            if common_attr_values is None:
-                common_attr_values = cube_attributes.copy()
-                common_keys = keys.copy()
-            local_keys.update(keys.symmetric_difference(common_keys))
-            common_keys.intersection_update(keys)
-            different_value_keys = []
-            for key in common_keys:
-                if np.any(common_attr_values[key] != cube_attributes[key]):
-                    different_value_keys.append(key)
-            common_keys.difference_update(different_value_keys)
-            local_keys.update(different_value_keys)
-
     def is_valid_packspec(p):
         """Only checks that the datatype is valid."""
         if isinstance(p, dict):