Fix sort function. Might need tweaking later. Minor test fixes.

hed/models/hed_group.py

@@ -143,22 +143,35 @@ def copy(self):
         return return_copy
 
     def sort(self):
+        """ Sort the tags and groups in this HedString in a consistent order.
+
+        Returns:
+            self
+        """
         self.sorted(update_self=True)
         return self
 
     def sorted(self, update_self=False):
+        """ Returns a sorted copy of this hed group as a list of it's children
+
+        Parameters:
+            update_self (bool): If True, update the contents of this group to be sorted as well.
+
+        Returns:
+            list: The list of all tags in this group, with subgroups being returned as further nested lists
+        """
         output_list = []
         queue_list = list(self.children)
         for child in queue_list:
             if isinstance(child, HedTag):
-                output_list.append(child)
+                output_list.append((child, child))
             else:
-                output_list.append(child.sorted(update_self))
+                output_list.append((child, child.sorted(update_self)))
 
-        output_list.sort(key=lambda x: str(x))
+        output_list.sort(key=lambda x: str(x[0]))
         if update_self:
-            self._contents = output_list
-        return output_list
+            self._children = [x[0] for x in output_list]
+        return [x[1] for x in output_list]
 
     @property
     def children(self):
@@ -534,4 +547,4 @@ def find_tags_with_term(self, term, recursive=False, include_groups=2):
 
         if include_groups == 0 or include_groups == 1:
             return [tag[include_groups] for tag in found_tags]
-        return found_tags
+        return found_tags

hed/validator/hed_validator.py

@@ -85,7 +85,14 @@ def _check_for_duplicate_groups_recursive(self, sorted_group, validation_issues)
                     validation_issues += ErrorHandler.format_error(error_code, child)
                 else:
                     error_code = ValidationErrors.HED_TAG_REPEATED_GROUP
-                    validation_issues += ErrorHandler.format_error(error_code, child[0]._parent)
+                    found_group = child
+                    base_steps_up = 0
+                    while isinstance(found_group, list):
+                        found_group = found_group[0]
+                        base_steps_up += 1
+                    for _ in range(base_steps_up):
+                        found_group = found_group._parent
+                    validation_issues += ErrorHandler.format_error(error_code, found_group)
             if not isinstance(child, HedTag):
                 self._check_for_duplicate_groups_recursive(child, validation_issues)
             prev_child = child

tests/models/test_sidecar.py

@@ -114,7 +114,7 @@ def test_duplicate_def(self):
 
     def test_save_load(self):
         sidecar = Sidecar(self.json_def_filename)
-        save_filename = self.base_output_folder + "test_sidecar_save.json"
+        save_filename = os.path.join(self.base_output_folder, "test_sidecar_save.json")
         sidecar.save_as_json(save_filename)
 
         reloaded_sidecar = Sidecar(save_filename)

tests/validator/test_tag_validator.py

@@ -388,12 +388,12 @@ def test_no_duplicates(self):
             'legalDuplicate': [],
             'noDuplicate': [],
             'duplicateGroup': self.format_error(ValidationErrors.HED_TAG_REPEATED_GROUP,
-                                                group=HedString("(Man-made-object/VehicleTrain, Sensory-event)")),
+                                                group=HedString("(Sensory-event, Man-made-object/VehicleTrain)")),
             'duplicateSubGroup': self.format_error(ValidationErrors.HED_TAG_REPEATED_GROUP,
-                                                group=HedString("(Event, (Man-made-object/VehicleTrain, Sensory-event))")),
+                                                group=HedString("(Event, (Sensory-event, Man-made-object/VehicleTrain))")),
             'duplicateSubGroupF': self.format_error(ValidationErrors.HED_TAG_REPEATED_GROUP,
                                                    group=HedString(
-                                                       "((Man-made-object/VehicleTrain, Sensory-event), Event)")),
+                                                       "((Sensory-event, Man-made-object/VehicleTrain), Event)")),
         }
         self.validator_syntactic(test_strings, expected_results, expected_issues, False)