Changed the ruff options -- resulted in reformatting

Author: VisLab

examples/validate_bids_dataset_with_libraries.ipynb

@@ -46,10 +46,12 @@
     "print(\"\\nNow validating with schema URLs.\")\n",
     "base_version = \"8.3.0\"\n",
     "library1_url = (\n",
-    "    \"https://raw.githubusercontent.com/hed-standard/hed-schemas/main/\" + \"library_schemas/score/hedxml/HED_score_2.0.0.xml\"\n",
+    "    \"https://raw.githubusercontent.com/hed-standard/hed-schemas/main/\"\n",
+    "    + \"library_schemas/score/hedxml/HED_score_2.0.0.xml\"\n",
     ")\n",
     "library2_url = (\n",
-    "    \"https://raw.githubusercontent.com/hed-standard/hed-schemas/main/\" + \"library_schemas/testlib/hedxml/HED_testlib_1.0.2.xml\"\n",
+    "    \"https://raw.githubusercontent.com/hed-standard/hed-schemas/main/\"\n",
+    "    + \"library_schemas/testlib/hedxml/HED_testlib_1.0.2.xml\"\n",
     ")\n",
     "schema_list = [load_schema(library1_url, schema_namespace=\"\"), load_schema(library2_url, schema_namespace=\"test\")]\n",
     "bids.schema = HedSchemaGroup(schema_list)\n",

hed/errors/error_messages.py

@@ -167,7 +167,9 @@ def val_error_invalid_extension(tag):
     return f'Invalid extension on tag - "{tag}"'
 
 
-@hed_tag_error(ValidationErrors.INVALID_PARENT_NODE, has_sub_tag=True, actual_code=ValidationErrors.TAG_EXTENSION_INVALID)
+@hed_tag_error(
+    ValidationErrors.INVALID_PARENT_NODE, has_sub_tag=True, actual_code=ValidationErrors.TAG_EXTENSION_INVALID
+)
 def val_error_invalid_parent(tag, problem_tag, expected_parent_tag):
     return f"In '{tag}', '{problem_tag}' appears as '{str(expected_parent_tag)}' and cannot be used as an extension."
 
@@ -192,7 +194,9 @@ def val_error_missing_column(column_name, column_type):
 
 @hed_error(ValidationErrors.HED_UNKNOWN_COLUMN, default_severity=ErrorSeverity.WARNING)
 def val_error_extra_column(column_name):
-    return f"Column named '{column_name}' found in file, but not specified as a tag column " + "or identified in sidecars."
+    return (
+        f"Column named '{column_name}' found in file, but not specified as a tag column " + "or identified in sidecars."
+    )
 
 
 @hed_error(ValidationErrors.SIDECAR_AND_OTHER_COLUMNS)
@@ -300,7 +304,8 @@ def val_error_tag_group_tag(tag):
 def val_error_top_level_tags(tag, multiple_tags):
     tags_as_string = [str(tag) for tag in multiple_tags]
     return (
-        f"Multiple top level tags found in a single group.  First one found: {str(tag)}. " + f"Remainder:{str(tags_as_string)}"
+        f"Multiple top level tags found in a single group.  First one found: {str(tag)}. "
+        + f"Remainder:{str(tags_as_string)}"
     )
 
 
@@ -359,9 +364,7 @@ def sidecar_na_used(column_name):
 
 @hed_tag_error(DefinitionErrors.DEF_TAG_IN_DEFINITION, actual_code=ValidationErrors.DEFINITION_INVALID)
 def def_error_def_tag_in_definition(tag, def_name):
-    return (
-        f"Invalid tag {tag} found in definition for {def_name}. Def, Def-expand, and Definition tags cannot be in definitions."
-    )
+    return f"Invalid tag {tag} found in definition for {def_name}. Def, Def-expand, and Definition tags cannot be in definitions."
 
 
 @hed_error(DefinitionErrors.NO_DEFINITION_CONTENTS, actual_code=ValidationErrors.DEFINITION_INVALID)
@@ -527,7 +530,9 @@ def improper_event_groups(event_types, string, line):
 
 
 @hed_error(
-    TagQualityErrors.MISSING_TASK_ROLE, default_severity=ErrorSeverity.WARNING, actual_code=TagQualityErrors.MISSING_TASK_ROLE
+    TagQualityErrors.MISSING_TASK_ROLE,
+    default_severity=ErrorSeverity.WARNING,
+    actual_code=TagQualityErrors.MISSING_TASK_ROLE,
 )
 def missing_task_role(event_type, string, line):
     return f"The HED string '{string}' at line {line} with event {event_type} has no Task-event-role type tag."

hed/errors/error_reporter.py

@@ -626,7 +626,10 @@ def create_doc_link(error_code):
     Returns:
         Union[str, None]: The URL if it's a valid code.
     """
-    if error_code in known_error_codes["hed_validation_errors"] or error_code in known_error_codes["schema_validation_errors"]:
+    if (
+        error_code in known_error_codes["hed_validation_errors"]
+        or error_code in known_error_codes["schema_validation_errors"]
+    ):
         modified_error_code = error_code.replace("_", "-").lower()
         return f"https://www.hedtags.org/hed-specification/Appendix_B.html#{modified_error_code}"
     return None

hed/errors/schema_error_messages.py

@@ -63,7 +63,10 @@ def schema_error_SCHEMA_PRERELEASE_VERSION_USED(current_version, known_versions)
 )
 def schema_error_invalid_character_prologue(char_index, source_string, section_name):
     invalid_char = source_string[char_index]
-    return f"'{section_name}' has invalid character '{invalid_char}' at " + f"position {char_index} of string: {source_string}"
+    return (
+        f"'{section_name}' has invalid character '{invalid_char}' at "
+        + f"position {char_index} of string: {source_string}"
+    )
 
 
 @hed_error(
@@ -114,7 +117,9 @@ def schema_error_SCHEMA_CHILD_OF_DEPRECATED(deprecated_tag, non_deprecated_child
     return f"Deprecated tag '{deprecated_tag}' has a child that is not deprecated: '{non_deprecated_child}'."
 
 
-@hed_error(SchemaAttributeErrors.SCHEMA_ATTRIBUTE_VALUE_DEPRECATED, actual_code=SchemaAttributeErrors.SCHEMA_DEPRECATION_ERROR)
+@hed_error(
+    SchemaAttributeErrors.SCHEMA_ATTRIBUTE_VALUE_DEPRECATED, actual_code=SchemaAttributeErrors.SCHEMA_DEPRECATION_ERROR
+)
 def schema_error_SCHEMA_ATTRIBUTE_VALUE_DEPRECATED(tag, deprecated_suggestion, attribute_name):
     return (
         f"Tag '{tag}' {attribute_name} uses '{deprecated_suggestion}' which has been deprecated "
@@ -131,7 +136,8 @@ def schema_error_GENERIC_ATTRIBUTE_VALUE_INVALID(tag, invalid_value, attribute_n
 
 
 @hed_error(
-    SchemaAttributeErrors.SCHEMA_ATTRIBUTE_NUMERIC_INVALID, actual_code=SchemaAttributeErrors.SCHEMA_ATTRIBUTE_VALUE_INVALID
+    SchemaAttributeErrors.SCHEMA_ATTRIBUTE_NUMERIC_INVALID,
+    actual_code=SchemaAttributeErrors.SCHEMA_ATTRIBUTE_VALUE_INVALID,
 )
 def schema_error_SCHEMA_ATTRIBUTE_NUMERIC_INVALID(tag, invalid_value, attribute_name):
     return f"Element '{tag}' has an invalid {attribute_name}: '{invalid_value}'.  Should be numeric."
@@ -145,7 +151,9 @@ def schema_error_SCHEMA_DEFAULT_UNITS_INVALID(tag, bad_unit, valid_units):
     return f"Tag '{tag}' has an invalid defaultUnit '{bad_unit}'.  Valid units are: '{valid_units}'."
 
 
-@hed_error(SchemaAttributeErrors.SCHEMA_DEFAULT_UNITS_DEPRECATED, actual_code=SchemaAttributeErrors.SCHEMA_DEPRECATION_ERROR)
+@hed_error(
+    SchemaAttributeErrors.SCHEMA_DEFAULT_UNITS_DEPRECATED, actual_code=SchemaAttributeErrors.SCHEMA_DEPRECATION_ERROR
+)
 def schema_error_SCHEMA_DEFAULT_UNITS_DEPRECATED(unit_class, bad_unit):
     return f"Unit class '{unit_class}' defaultUnit '{bad_unit}' is deprecated.  Please find an alternative default."
 
@@ -158,7 +166,9 @@ def schema_error_SCHEMA_CONVERSION_FACTOR_NOT_POSITIVE(tag, conversion_factor):
     return f"Tag '{tag}' has an invalid conversionFactor '{conversion_factor}'.  Conversion factor must be positive."
 
 
-@hed_error(SchemaAttributeErrors.SCHEMA_HED_ID_INVALID, actual_code=SchemaAttributeErrors.SCHEMA_ATTRIBUTE_VALUE_INVALID)
+@hed_error(
+    SchemaAttributeErrors.SCHEMA_HED_ID_INVALID, actual_code=SchemaAttributeErrors.SCHEMA_ATTRIBUTE_VALUE_INVALID
+)
 def schema_error_SCHEMA_HED_ID_INVALID(tag, new_id, old_id=None, valid_min=None, valid_max=None):
     if old_id:
         return (
@@ -171,7 +181,8 @@ def schema_error_SCHEMA_HED_ID_INVALID(tag, new_id, old_id=None, valid_min=None,
 
 
 @hed_error(
-    SchemaAttributeErrors.SCHEMA_ALLOWED_CHARACTERS_INVALID, actual_code=SchemaAttributeErrors.SCHEMA_ATTRIBUTE_VALUE_INVALID
+    SchemaAttributeErrors.SCHEMA_ALLOWED_CHARACTERS_INVALID,
+    actual_code=SchemaAttributeErrors.SCHEMA_ATTRIBUTE_VALUE_INVALID,
 )
 def schema_error_SCHEMA_ALLOWED_CHARACTERS_INVALID(tag, invalid_character):
     from hed.schema.hed_schema_constants import character_types
@@ -183,7 +194,9 @@ def schema_error_SCHEMA_ALLOWED_CHARACTERS_INVALID(tag, invalid_character):
     )
 
 
-@hed_error(SchemaAttributeErrors.SCHEMA_IN_LIBRARY_INVALID, actual_code=SchemaAttributeErrors.SCHEMA_ATTRIBUTE_VALUE_INVALID)
+@hed_error(
+    SchemaAttributeErrors.SCHEMA_IN_LIBRARY_INVALID, actual_code=SchemaAttributeErrors.SCHEMA_ATTRIBUTE_VALUE_INVALID
+)
 def schema_error_SCHEMA_IN_LIBRARY_INVALID(tag, bad_library):
     return f"Tag '{tag}' has an invalid inLibrary: '{bad_library}'.  "
 
@@ -198,9 +211,7 @@ def schema_error_SCHEMA_MISSING_EXTRA_VALUE(section_name, column_name, row_index
     default_severity=ErrorSeverity.WARNING,
 )
 def schema_error_annotation_prefix_missing(tag, annotation_value, prefix):
-    return (
-        f"Tag '{tag}' has annotation '{annotation_value}' with prefix '{prefix}' that is not defined in the Prefixes section."
-    )
+    return f"Tag '{tag}' has annotation '{annotation_value}' with prefix '{prefix}' that is not defined in the Prefixes section."
 
 
 @hed_error(

hed/models/base_input.py

@@ -21,7 +21,14 @@ class BaseInput:
     EXCEL_EXTENSION = [".xlsx"]
 
     def __init__(
-        self, file, file_type=None, worksheet_name=None, has_column_names=True, mapper=None, name=None, allow_blank_names=True
+        self,
+        file,
+        file_type=None,
+        worksheet_name=None,
+        has_column_names=True,
+        mapper=None,
+        name=None,
+        allow_blank_names=True,
     ):
         """Constructor for the BaseInput class.
 
@@ -562,7 +569,9 @@ def _load_excel_file(self, file, has_column_names):
             loaded_worksheet = self.get_worksheet(self._worksheet_name)
             self._dataframe = self._get_dataframe_from_worksheet(loaded_worksheet, has_column_names)
         except Exception as e:
-            raise HedFileError(HedExceptions.INVALID_FILE_FORMAT, f"Failed to load Excel file: {str(e)}", self.name) from e
+            raise HedFileError(
+                HedExceptions.INVALID_FILE_FORMAT, f"Failed to load Excel file: {str(e)}", self.name
+            ) from e
 
     def _load_text_file(self, file, pandas_header):
         """Load a text file (TSV/CSV) into a pandas DataFrame.
@@ -611,4 +620,6 @@ def _load_text_file(self, file, pandas_header):
         except pd.errors.EmptyDataError:
             self._dataframe = pd.DataFrame()  # Handle case where file has no data
         except Exception as e:
-            raise HedFileError(HedExceptions.INVALID_FILE_FORMAT, f"Failed to load text file: {str(e)}", self.name) from e
+            raise HedFileError(
+                HedExceptions.INVALID_FILE_FORMAT, f"Failed to load text file: {str(e)}", self.name
+            ) from e

hed/models/column_mapper.py

@@ -320,12 +320,16 @@ def _check_for_duplicates_and_required(self, list_names, column_lists) -> list[d
         issues = []
         for list_name, col_list in zip(list_names, column_lists, strict=False):
             # Convert all known strings to ints, then check for duplicates
-            converted_list = [item if isinstance(item, int) else self._reverse_column_map.get(item, item) for item in col_list]
+            converted_list = [
+                item if isinstance(item, int) else self._reverse_column_map.get(item, item) for item in col_list
+            ]
 
             if col_list != self._optional_tag_columns:
                 for test_col in converted_list:
                     if isinstance(test_col, str) and test_col not in self._reverse_column_map:
-                        issues += ErrorHandler.format_error(ValidationErrors.HED_MISSING_REQUIRED_COLUMN, test_col, list_name)
+                        issues += ErrorHandler.format_error(
+                            ValidationErrors.HED_MISSING_REQUIRED_COLUMN, test_col, list_name
+                        )
 
             issues += self._check_for_duplicates_between_lists(
                 converted_list, list_name, ValidationErrors.DUPLICATE_COLUMN_IN_LIST

hed/models/definition_dict.py

@@ -148,7 +148,10 @@ def check_for_definitions(self, hed_string_obj, error_handler=None) -> list[dict
 
             if "/" in def_tag_name or "#" in def_tag_name:
                 new_def_issues += ErrorHandler.format_error_with_context(
-                    error_handler, DefinitionErrors.INVALID_DEFINITION_EXTENSION, tag=definition_tag, def_name=def_tag_name
+                    error_handler,
+                    DefinitionErrors.INVALID_DEFINITION_EXTENSION,
+                    tag=definition_tag,
+                    def_name=def_tag_name,
                 )
 
             if new_def_issues:
@@ -294,13 +297,19 @@ def _validate_contents(definition_tag, group, error_handler):
             def_keys = {DefTagNames.DEF_KEY, DefTagNames.DEF_EXPAND_KEY, DefTagNames.DEFINITION_KEY}
             for def_tag in group.find_tags(def_keys, recursive=True, include_groups=0):
                 issues += ErrorHandler.format_error_with_context(
-                    error_handler, DefinitionErrors.DEF_TAG_IN_DEFINITION, tag=def_tag, def_name=definition_tag.extension
+                    error_handler,
+                    DefinitionErrors.DEF_TAG_IN_DEFINITION,
+                    tag=def_tag,
+                    def_name=definition_tag.extension,
                 )
 
             for tag in group.get_all_tags():
                 if tag.has_attribute(HedKey.Unique) or tag.has_attribute(HedKey.Required):
                     issues += ErrorHandler.format_error_with_context(
-                        error_handler, DefinitionErrors.BAD_PROP_IN_DEFINITION, tag=tag, def_name=definition_tag.extension
+                        error_handler,
+                        DefinitionErrors.BAD_PROP_IN_DEFINITION,
+                        tag=tag,
+                        def_name=definition_tag.extension,
                     )
 
         return issues

hed/models/df_util.py

@@ -71,7 +71,9 @@ def expand_defs(df, hed_schema, def_dict, columns=None):
 
         for column in columns:
             mask = df[column].str.contains("Def/", case=False)
-            df.loc[mask, column] = df.loc[mask, column].apply(partial(_expand_defs, hed_schema=hed_schema, def_dict=def_dict))
+            df.loc[mask, column] = df.loc[mask, column].apply(
+                partial(_expand_defs, hed_schema=hed_schema, def_dict=def_dict)
+            )
 
 
 def _convert_to_form(hed_string, hed_schema, tag_form):
@@ -86,7 +88,9 @@ def _expand_defs(hed_string, hed_schema, def_dict):
     return str(HedString(hed_string, hed_schema, def_dict).expand_defs())
 
 
-def process_def_expands(hed_strings, hed_schema, known_defs=None, ambiguous_defs=None) -> tuple["DefinitionDict", dict, dict]:
+def process_def_expands(
+    hed_strings, hed_schema, known_defs=None, ambiguous_defs=None
+) -> tuple["DefinitionDict", dict, dict]:
     """Gather def-expand tags in the strings/compare with known definitions to find any differences.
 
     Parameters:
@@ -235,7 +239,9 @@ def split_delay_tags(series, hed_schema, onsets):
         return None
     split_df = pd.DataFrame({"onset": onsets, "HED": series, "original_index": series.index})
     delay_strings = [
-        (i, HedString(hed_string, hed_schema)) for (i, hed_string) in series.items() if "delay/" in hed_string.casefold()
+        (i, HedString(hed_string, hed_schema))
+        for (i, hed_string) in series.items()
+        if "delay/" in hed_string.casefold()
     ]
     delay_groups = []
     for i, delay_string in delay_strings:

hed/models/tabular_input.py

@@ -36,7 +36,9 @@ def __init__(self, file=None, sidecar=None, name=None):
         """
         if sidecar and not isinstance(sidecar, Sidecar):
             sidecar = Sidecar(sidecar)
-        new_mapper = ColumnMapper(sidecar=sidecar, optional_tag_columns=[self.HED_COLUMN_NAME], warn_on_missing_column=True)
+        new_mapper = ColumnMapper(
+            sidecar=sidecar, optional_tag_columns=[self.HED_COLUMN_NAME], warn_on_missing_column=True
+        )
 
         self._sidecar = sidecar
 

hed/schema/hed_cache.py

@@ -134,7 +134,9 @@ def get_hed_versions(local_hed_directory=None, library_name=None, check_prerelea
     return all_hed_versions
 
 
-def get_hed_version_path(xml_version, library_name=None, local_hed_directory=None, check_prerelease=False) -> Union[str, None]:
+def get_hed_version_path(
+    xml_version, library_name=None, local_hed_directory=None, check_prerelease=False
+) -> Union[str, None]:
     """Get HED XML file path in a directory.  Only returns filenames that exist.
 
     Parameters:
@@ -226,7 +228,9 @@ def cache_xml_versions(
                 new_hed_versions = _get_hed_xml_versions_one_library(hed_base_url)
                 _merge_in_versions(all_hed_versions, new_hed_versions)
             for hed_library_url in hed_library_urls:
-                new_hed_versions = _get_hed_xml_versions_from_url_all_libraries(hed_library_url, skip_folders=skip_folders)
+                new_hed_versions = _get_hed_xml_versions_from_url_all_libraries(
+                    hed_library_url, skip_folders=skip_folders
+                )
                 _merge_in_versions(all_hed_versions, new_hed_versions)
 
             for library_name, hed_versions in all_hed_versions.items():