Removed the hardcoded default for cache

Author: VisLab

CHANGELOG.md

@@ -12,6 +12,7 @@ Previously, loading a schema whose version existed only in the prerelease cache
 - Removed the parameter from `SchemaLoader` (base class) and all subclasses (`SchemaLoaderXML`, `SchemaLoaderWiki`, `SchemaLoaderJSON`, `SchemaLoaderDF`).
 - `get_hed_version_path()` in `hed_cache.py` now always searches both regular and prerelease directories (regular first).
 - `get_hed_versions()` in `hed_cache.py` now defaults to `check_prerelease=True`; the compliance checker explicitly passes `False` to compare against released versions only.
+- Default schema version is now resolved dynamically from the cache (highest released version) instead of being hardcoded, so new schema releases no longer require a code change.
 - `check_schema_loading.py` simplified — removed `_is_prerelease_partner()` helper.
 - `run_loading_check()` now raises `ValueError` immediately for mutually exclusive flag combinations (`prerelease_only` + `exclude_prereleases`, or `library_filter` + `standard_only`), consistent with the existing CLI-level validation.
 

hed/schema/hed_cache.py

@@ -102,7 +102,7 @@ def get_hed_versions(local_hed_directory=None, library_name=None, check_prerelea
 
     all_hed_versions = {}
     local_directories = [local_hed_directory]
-    if check_prerelease and not local_hed_directory.endswith(prerelease_suffix):
+    if check_prerelease and Path(local_hed_directory).name != "prerelease":
         local_directories.append(os.path.join(local_hed_directory, "prerelease"))
 
     hed_files = []
@@ -135,9 +135,7 @@ 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
-) -> Union[str, None]:
+def get_hed_version_path(xml_version, library_name=None, local_hed_directory=None) -> Union[str, None]:
     """Get HED XML file path in a directory. Only returns filenames that exist.
 
     Parameters:
@@ -146,7 +144,7 @@ def get_hed_version_path(
         local_hed_directory (str): Path to local HED directory. Defaults to HED_CACHE_DIRECTORY
 
     Returns:
-        Union[str, None]: The path to the latest HED version the HED directory.
+        Union[str, None]: The path to the requested HED version the HED directory.
 
     """
     if not local_hed_directory:

hed/schema/hed_schema_io.py

@@ -22,9 +22,7 @@
 MAX_MEMORY_CACHE = 40
 
 
-def load_schema_version(
-    xml_version=None, xml_folder=None
-) -> Union["HedSchema", "HedSchemaGroup"]:
+def load_schema_version(xml_version=None, xml_folder=None) -> Union["HedSchema", "HedSchemaGroup"]:
     """Return a HedSchema or HedSchemaGroup extracted from xml_version
 
     Parameters:
@@ -52,8 +50,7 @@ def load_schema_version(
     if xml_version and isinstance(xml_version, list):
         xml_versions = parse_version_list(xml_version)
         schemas = [
-            _load_schema_version(xml_version=version, xml_folder=xml_folder)
-            for version in xml_versions.values()
+            _load_schema_version(xml_version=version, xml_folder=xml_folder) for version in xml_versions.values()
         ]
         if len(schemas) == 1:
             return schemas[0]
@@ -125,9 +122,7 @@ def load_schema(hed_path, schema_namespace=None, schema=None, name=None) -> "Hed
     return hed_schema
 
 
-def from_string(
-    schema_string, schema_format=".xml", schema_namespace=None, schema=None, name=None
-) -> "HedSchema":
+def from_string(schema_string, schema_format=".xml", schema_namespace=None, schema=None, name=None) -> "HedSchema":
     """Create a schema from the given string.
 
     Parameters:
@@ -158,17 +153,11 @@ def from_string(
         schema_string = schema_string.replace("\r\n", "\n")
 
     if schema_format.endswith(".xml"):
-        hed_schema = SchemaLoaderXML.load(
-            schema_as_string=schema_string, schema=schema, name=name
-        )
+        hed_schema = SchemaLoaderXML.load(schema_as_string=schema_string, schema=schema, name=name)
     elif schema_format.endswith(".mediawiki"):
-        hed_schema = SchemaLoaderWiki.load(
-            schema_as_string=schema_string, schema=schema, name=name
-        )
+        hed_schema = SchemaLoaderWiki.load(schema_as_string=schema_string, schema=schema, name=name)
     elif schema_format.endswith(".json"):
-        hed_schema = SchemaLoaderJSON.load(
-            schema_as_string=schema_string, schema=schema, name=name
-        )
+        hed_schema = SchemaLoaderJSON.load(schema_as_string=schema_string, schema=schema, name=name)
     else:
         raise HedFileError(HedExceptions.INVALID_EXTENSION, f"Unknown schema extension {schema_format}", filename=name)
 
@@ -202,9 +191,7 @@ def from_dataframes(schema_data, schema_namespace=None, name=None) -> "HedSchema
             HedExceptions.BAD_PARAMETERS, "Empty or non dict value passed to HedSchema.from_dataframes", filename=name
         )
 
-    hed_schema = SchemaLoaderDF.load_spreadsheet(
-        schema_as_strings_or_df=schema_data, name=name
-    )
+    hed_schema = SchemaLoaderDF.load_spreadsheet(schema_as_strings_or_df=schema_data, name=name)
 
     if schema_namespace:
         hed_schema.set_schema_prefix(schema_namespace=schema_namespace)
@@ -302,9 +289,7 @@ def _load_schema_version(xml_version=None, xml_folder=None):
     else:
         xml_versions = [""]
 
-    first_schema = _load_schema_version_sub(
-        xml_versions[0], schema_namespace, xml_folder=xml_folder, name=name
-    )
+    first_schema = _load_schema_version_sub(xml_versions[0], schema_namespace, xml_folder=xml_folder, name=name)
     filenames = [os.path.basename(first_schema.filename)]
 
     # Collect all duplicate issues for proper error reporting
@@ -350,13 +335,12 @@ def _load_schema_version(xml_version=None, xml_folder=None):
     return first_schema
 
 
-def _load_schema_version_sub(
-    xml_version, schema_namespace="", xml_folder=None, schema=None, name=""
-):
-    """Return specified version(single version only for this one)
+def _load_schema_version_sub(xml_version, schema_namespace="", xml_folder=None, schema=None, name=""):
+    """Return specified version (single version only for this one).
 
     Parameters:
-        xml_version (str): HED version format string. Expected format: '[library_name_]X.Y.Z'
+        xml_version (str): HED version format string. Expected format: '[library_name_]X.Y.Z'.
+                           If empty, the latest released standard schema version from the cache is used.
         schema_namespace (str): The prefix this will have
         xml_folder (str): Path to a folder containing schema
         schema (HedSchema or None): A HED schema to merge this new file into.
@@ -373,7 +357,15 @@ def _load_schema_version_sub(
         - The prefix is invalid
     """
     if not xml_version:
-        xml_version = "8.4.0"
+        versions = hed_cache.get_hed_versions(xml_folder, check_prerelease=False)
+        if versions:
+            xml_version = versions[0]
+        else:
+            raise HedFileError(
+                HedExceptions.FILE_NOT_FOUND,
+                "No HED schema versions found in cache. Ensure schemas are installed or cached.",
+                "",
+            )
 
     # Parse library name from version string before validation
     library_name = ""
@@ -400,9 +392,7 @@ def _load_schema_version_sub(
         hed_schema = load_schema(hed_file_path, schema_namespace=schema_namespace, schema=schema, name=name)
     else:
         library_string = f"for library '{library_name}'" if library_name else ""
-        known_versions = hed_cache.get_hed_versions(
-            xml_folder, library_name=library_name if library_name else "all"
-        )
+        known_versions = hed_cache.get_hed_versions(xml_folder, library_name=library_name if library_name else "all")
         raise HedFileError(
             HedExceptions.FILE_NOT_FOUND,
             f"HED version {library_string}: '{version_to_validate}' not found. Check {hed_cache.get_cache_directory(xml_folder)} for cache or https://github.com/hed-standard/hed-schemas/tree/main/library_schemas. "

hed/schema/schema_io/df2schema.py

@@ -45,9 +45,7 @@ def load_spreadsheet(cls, filenames=None, schema_as_strings_or_df=None, name="")
         Returns:
             HedSchema: The new schema
         """
-        loader = cls(
-            filenames, schema_as_strings_or_df=schema_as_strings_or_df, name=name
-        )
+        loader = cls(filenames, schema_as_strings_or_df=schema_as_strings_or_df, name=name)
         hed_schema = loader._load()
         return hed_schema
 

hed/scripts/schema_script_util.py

@@ -38,9 +38,7 @@ def validate_schema_object(base_schema, schema_name, check_for_warnings=False):
         for save_merged in (True, False):
             label = "merged" if save_merged else "unmerged"
             tagged_name = f"{schema_name} ({label})"
-            validation_issues += _roundtrip_all_formats(
-                base_schema, tagged_name, save_merged=save_merged
-            )
+            validation_issues += _roundtrip_all_formats(base_schema, tagged_name, save_merged=save_merged)
     except HedFileError as e:
         print(f"Saving/loading error: {schema_name} {e.message}")
         error_text = e.message

spec_tests/test_hed_cache.py

@@ -79,10 +79,15 @@ def test_get_hed_versions_library(self):
         self.assertTrue(len(cached_versions) > 0)
 
     def test_get_hed_versions_library_prerelease(self):
-        # Todo: improve this code to actually test it.
-        cached_versions = hed_cache.get_hed_versions(self.hed_cache_dir, library_name="score")
-        self.assertIsInstance(cached_versions, list)
-        self.assertTrue(len(cached_versions) > 0)
+        all_versions = hed_cache.get_hed_versions(self.hed_cache_dir, library_name="score")
+        released_only = hed_cache.get_hed_versions(self.hed_cache_dir, library_name="score", check_prerelease=False)
+        self.assertIsInstance(all_versions, list)
+        self.assertTrue(len(all_versions) > 0)
+        self.assertGreater(
+            len(all_versions),
+            len(released_only),
+            "Default (prerelease included) should return more versions than released-only",
+        )
 
     def test_sort_version_list(self):
         valid_versions = ["8.1.0", "8.0.0", "8.0.0-alpha.1", "7.1.1", "1.0.0"]