Removed the prerelease flag from schema loading

Author: VisLab

CHANGELOG.md

@@ -2,15 +2,17 @@
 
 ## Enhancements
 
-### Prerelease library schemas can now partner with prerelease standard schemas
+### Prerelease schemas are now always included in version lookups
 
-Loading a library schema with `withStandard` pointing to a prerelease version of the standard schema (e.g. `withStandard="8.5.0"`) would fail with a `BAD_WITH_STANDARD` error because the `withStandard` partner lookup was always restricted to released schemas, with no way to opt in to prerelease partner resolution.
+Previously, loading a schema whose version existed only in the prerelease cache required passing `check_prerelease=True` through every layer of the loading API. This flag has been **removed** from all public functions (`load_schema_version`, `load_schema`, `from_string`, `from_dataframes`), all schema loader classes, and all internal helpers. Prerelease schemas are now found automatically whenever they are present in the cache.
 
 **Changes:**
 
-- `load_schema()` and `from_string()` in `hed_schema_io.py` now accept a `check_prerelease=False` parameter. When `True`, the `withStandard` partner schema is also searched in the prerelease cache.
-- `SchemaLoader` (base class) and all subclasses (`SchemaLoaderXML`, `SchemaLoaderWiki`, `SchemaLoaderJSON`, `SchemaLoaderDF`) accept and forward `check_prerelease`.
-- `check_schema_loading.py` (`hed_check_schema_loading` script and `run_loading_check()`) now automatically passes `check_prerelease=True` when loading schemas from a prerelease directory, so `test_all_prerelease_schemas` in `spec_tests` works correctly for library prereleases partnered with a prerelease standard.
+- Removed the `check_prerelease` parameter from `load_schema_version()`, `load_schema()`, `from_string()`, and `from_dataframes()` in `hed_schema_io.py`.
+- 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.
+- `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.
 
 # Release 0.9.0 January 22, 2026

hed/schema/hed_cache.py

@@ -79,15 +79,16 @@ def get_cache_directory(cache_folder=None) -> str:
     return HED_CACHE_DIRECTORY
 
 
-def get_hed_versions(local_hed_directory=None, library_name=None, check_prerelease=False) -> Union[list, dict]:
+def get_hed_versions(local_hed_directory=None, library_name=None, check_prerelease=True) -> Union[list, dict]:
     """Get the HED versions in the HED directory.
 
     Parameters:
         local_hed_directory (str): Directory to check for versions which defaults to hed_cache.
         library_name (str or None): An optional schema library name.
                                     None retrieves the standard schema only.
                                     Pass "all" to retrieve all standard and library schemas as a dict.
-        check_prerelease (bool): If True, results can include prerelease schemas
+        check_prerelease (bool): If True, results can include prerelease schemas.
+                                 Pass False to get only released versions (used by compliance checks).
 
     Returns:
         Union[list, dict]: List of version numbers or dictionary {library_name: [versions]}.
@@ -135,15 +136,14 @@ def get_hed_versions(local_hed_directory=None, library_name=None, check_prerelea
 
 
 def get_hed_version_path(
-    xml_version, library_name=None, local_hed_directory=None, check_prerelease=False
+    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:
-        library_name (str or None): Optional the schema library name.
         xml_version (str): Returns this version if it exists
+        library_name (str or None): Optional the schema library name.
         local_hed_directory (str): Path to local HED directory. Defaults to HED_CACHE_DIRECTORY
-        check_prerelease (bool): Also check for prerelease schemas
 
     Returns:
         Union[str, None]: The path to the latest HED version the HED directory.
@@ -152,7 +152,7 @@ def get_hed_version_path(
     if not local_hed_directory:
         local_hed_directory = HED_CACHE_DIRECTORY
 
-    hed_versions = get_hed_versions(local_hed_directory, library_name, check_prerelease)
+    hed_versions = get_hed_versions(local_hed_directory, library_name)
     if not hed_versions or not xml_version:
         return None
     if xml_version in hed_versions:
@@ -161,11 +161,10 @@ def get_hed_version_path(
         if os.path.exists(regular_path):
             return regular_path
 
-        # If check_prerelease is True, also check prerelease directory
-        if check_prerelease:
-            prerelease_path = _create_xml_filename(xml_version, library_name, local_hed_directory, True)
-            if os.path.exists(prerelease_path):
-                return prerelease_path
+        # Also check prerelease directory
+        prerelease_path = _create_xml_filename(xml_version, library_name, local_hed_directory, True)
+        if os.path.exists(prerelease_path):
+            return prerelease_path
     return None
 
 

hed/schema/hed_schema_io.py

@@ -23,7 +23,7 @@
 
 
 def load_schema_version(
-    xml_version=None, xml_folder=None, check_prerelease=False
+    xml_version=None, xml_folder=None
 ) -> Union["HedSchema", "HedSchemaGroup"]:
     """Return a HedSchema or HedSchemaGroup extracted from xml_version
 
@@ -33,7 +33,6 @@ def load_schema_version(
                                            based on the output of HedSchema.get_formatted_version
                                            Basic format: `[schema_namespace:][library_name_]X.Y.Z`.
         xml_folder (str): Path to a folder containing schema.
-        check_prerelease (bool): If True, check the prerelease directory for schemas.
 
     Returns:
         Union[HedSchema, HedSchemaGroup]: The schema or schema group extracted.
@@ -53,7 +52,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, check_prerelease=check_prerelease)
+            _load_schema_version(xml_version=version, xml_folder=xml_folder)
             for version in xml_versions.values()
         ]
         if len(schemas) == 1:
@@ -62,10 +61,10 @@ def load_schema_version(
         name = ",".join([schema.version for schema in schemas])
         return HedSchemaGroup(schemas, name=name)
     else:
-        return _load_schema_version(xml_version=xml_version, xml_folder=xml_folder, check_prerelease=check_prerelease)
+        return _load_schema_version(xml_version=xml_version, xml_folder=xml_folder)
 
 
-def load_schema(hed_path, schema_namespace=None, schema=None, name=None, check_prerelease=False) -> "HedSchema":
+def load_schema(hed_path, schema_namespace=None, schema=None, name=None) -> "HedSchema":
     """Load a schema from the given file or URL path.
 
     Parameters:
@@ -77,7 +76,6 @@ def load_schema(hed_path, schema_namespace=None, schema=None, name=None, check_p
         schema (HedSchema or None): A HED schema to merge this new file into
                                    It must be a with-standard schema with the same value.
         name (str or None): User supplied identifier for this schema
-        check_prerelease (bool): If True, allow the partnered standard schema (withStandard) to be a prerelease version.
 
     Returns:
         HedSchema: The loaded schema.
@@ -103,22 +101,21 @@ def load_schema(hed_path, schema_namespace=None, schema=None, name=None, check_p
             file_as_string,
             schema_format=os.path.splitext(hed_path.lower())[1],
             name=name,
-            check_prerelease=check_prerelease,
         )
     elif hed_path.lower().endswith(".xml"):
-        hed_schema = SchemaLoaderXML.load(hed_path, schema=schema, name=name, check_prerelease=check_prerelease)
+        hed_schema = SchemaLoaderXML.load(hed_path, schema=schema, name=name)
     elif hed_path.lower().endswith(".mediawiki"):
-        hed_schema = SchemaLoaderWiki.load(hed_path, schema=schema, name=name, check_prerelease=check_prerelease)
+        hed_schema = SchemaLoaderWiki.load(hed_path, schema=schema, name=name)
     elif hed_path.lower().endswith(".json"):
-        hed_schema = SchemaLoaderJSON.load(hed_path, schema=schema, name=name, check_prerelease=check_prerelease)
+        hed_schema = SchemaLoaderJSON.load(hed_path, schema=schema, name=name)
     elif hed_path.lower().endswith(".tsv") or os.path.isdir(hed_path):
         if schema is not None:
             raise HedFileError(
                 HedExceptions.INVALID_HED_FORMAT,
                 "Cannot pass a schema to merge into spreadsheet loading currently.",
                 filename=name,
             )
-        hed_schema = SchemaLoaderDF.load_spreadsheet(filenames=hed_path, name=name, check_prerelease=check_prerelease)
+        hed_schema = SchemaLoaderDF.load_spreadsheet(filenames=hed_path, name=name)
     else:
         raise HedFileError(HedExceptions.INVALID_EXTENSION, "Unknown schema extension", filename=hed_path)
 
@@ -129,7 +126,7 @@ def load_schema(hed_path, schema_namespace=None, schema=None, name=None, check_p
 
 
 def from_string(
-    schema_string, schema_format=".xml", schema_namespace=None, schema=None, name=None, check_prerelease=False
+    schema_string, schema_format=".xml", schema_namespace=None, schema=None, name=None
 ) -> "HedSchema":
     """Create a schema from the given string.
 
@@ -141,7 +138,6 @@ def from_string(
         schema (HedSchema or None): A HED schema to merge this new file into
                                    It must be a with-standard schema with the same value.
         name (str or None): User supplied identifier for this schema
-        check_prerelease (bool): If True, allow the partnered standard schema (withStandard) to be a prerelease version.
 
     Returns:
         HedSchema: The loaded schema.
@@ -163,15 +159,15 @@ def from_string(
 
     if schema_format.endswith(".xml"):
         hed_schema = SchemaLoaderXML.load(
-            schema_as_string=schema_string, schema=schema, name=name, check_prerelease=check_prerelease
+            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, check_prerelease=check_prerelease
+            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, check_prerelease=check_prerelease
+            schema_as_string=schema_string, schema=schema, name=name
         )
     else:
         raise HedFileError(HedExceptions.INVALID_EXTENSION, f"Unknown schema extension {schema_format}", filename=name)
@@ -181,15 +177,14 @@ def from_string(
     return hed_schema
 
 
-def from_dataframes(schema_data, schema_namespace=None, name=None, check_prerelease=False) -> "HedSchema":
+def from_dataframes(schema_data, schema_namespace=None, name=None) -> "HedSchema":
     """Create a schema from the given string.
 
     Parameters:
         schema_data (dict of str or None): A dict of DF_SUFFIXES:file_as_string_or_df
                               Should have an entry for all values of DF_SUFFIXES.
         schema_namespace (str, None):  The name_prefix all tags in this schema will accept.
         name (str or None): User supplied identifier for this schema
-        check_prerelease (bool): If True, allow the partnered standard schema (withStandard) to be a prerelease version.
 
     Returns:
         HedSchema:  The loaded schema.
@@ -208,7 +203,7 @@ def from_dataframes(schema_data, schema_namespace=None, name=None, check_prerele
         )
 
     hed_schema = SchemaLoaderDF.load_spreadsheet(
-        schema_as_strings_or_df=schema_data, name=name, check_prerelease=check_prerelease
+        schema_as_strings_or_df=schema_data, name=name
     )
 
     if schema_namespace:
@@ -274,7 +269,7 @@ def parse_version_list(xml_version_list) -> dict:
 
 
 @functools.lru_cache(maxsize=MAX_MEMORY_CACHE)
-def _load_schema_version(xml_version=None, xml_folder=None, check_prerelease=False):
+def _load_schema_version(xml_version=None, xml_folder=None):
     """Return specified version
 
     Parameters:
@@ -284,7 +279,6 @@ def _load_schema_version(xml_version=None, xml_folder=None, check_prerelease=Fal
                            The schema namespace must be the same and not repeated if loading multiple merged schemas.
 
         xml_folder (str): Path to a folder containing schema.
-        check_prerelease (bool): If True, check the prerelease directory for schemas.
 
     Returns:
         Union[HedSchema, HedSchemaGroup]: The requested HedSchema object.
@@ -309,7 +303,7 @@ def _load_schema_version(xml_version=None, xml_folder=None, check_prerelease=Fal
         xml_versions = [""]
 
     first_schema = _load_schema_version_sub(
-        xml_versions[0], schema_namespace, xml_folder=xml_folder, check_prerelease=check_prerelease, name=name
+        xml_versions[0], schema_namespace, xml_folder=xml_folder, name=name
     )
     filenames = [os.path.basename(first_schema.filename)]
 
@@ -321,7 +315,6 @@ def _load_schema_version(xml_version=None, xml_folder=None, check_prerelease=Fal
             version,
             schema_namespace,
             xml_folder=xml_folder,
-            check_prerelease=check_prerelease,
             schema=first_schema,
             name=name,
         )
@@ -358,15 +351,14 @@ def _load_schema_version(xml_version=None, xml_folder=None, check_prerelease=Fal
 
 
 def _load_schema_version_sub(
-    xml_version, schema_namespace="", xml_folder=None, check_prerelease=False, schema=None, name=""
+    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'
         schema_namespace (str): The prefix this will have
         xml_folder (str): Path to a folder containing schema
-        check_prerelease (bool): If True, check the prerelease directory for schemas
         schema (HedSchema or None): A HED schema to merge this new file into.
         name (str): User supplied identifier for this schema
 
@@ -402,15 +394,14 @@ def _load_schema_version_sub(
         version_to_validate,
         library_name=library_name,
         local_hed_directory=xml_folder,
-        check_prerelease=check_prerelease,
     )
 
     if hed_file_path:
         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", check_prerelease=check_prerelease
+            xml_folder, library_name=library_name if library_name else "all"
         )
         raise HedFileError(
             HedExceptions.FILE_NOT_FOUND,

hed/schema/schema_io/base2schema.py

@@ -20,7 +20,7 @@ class SchemaLoader(ABC):
     SchemaLoaderXML(filename) will load just the header_attributes
     """
 
-    def __init__(self, filename, schema_as_string=None, schema=None, file_format=None, name="", check_prerelease=False):
+    def __init__(self, filename, schema_as_string=None, schema=None, file_format=None, name=""):
         """Loads the given schema from one of the two parameters.
 
         Parameters:
@@ -30,7 +30,6 @@ def __init__(self, filename, schema_as_string=None, schema=None, file_format=Non
                                        It must be a with-standard schema with the same value.
             file_format(str or None): The format of this file if needed(only for owl currently)
             name(str or None): Optional user supplied identifier, by default uses filename
-            check_prerelease(bool): If True, allow the partnered standard schema to be a prerelease version.
         """
         if schema_as_string and filename:
             raise HedFileError(HedExceptions.BAD_PARAMETERS, "Invalid parameters to schema creation.", filename)
@@ -39,7 +38,6 @@ def __init__(self, filename, schema_as_string=None, schema=None, file_format=Non
         self.name = name if name else filename
         self.schema_as_string = schema_as_string
         self.appending_to_schema = False
-        self.check_prerelease = check_prerelease
         try:
             self.input_data = self._open_file()
         except OSError as e:
@@ -89,7 +87,7 @@ def schema(self):
         return self._schema
 
     @classmethod
-    def load(cls, filename=None, schema_as_string=None, schema=None, file_format=None, name="", check_prerelease=False):
+    def load(cls, filename=None, schema_as_string=None, schema=None, file_format=None, name=""):
         """Loads and returns the schema, including partnered schema if applicable.
 
         Parameters:
@@ -100,12 +98,11 @@ def load(cls, filename=None, schema_as_string=None, schema=None, file_format=Non
             file_format(str or None): If this is an owl file being loaded, this is the format.
                 Allowed values include: turtle, json-ld, and owl(xml)
             name(str or None): Optional user supplied identifier, by default uses filename
-            check_prerelease(bool): If True, allow the partnered standard schema to be a prerelease version.
 
         Returns:
             HedSchema: The new schema
         """
-        loader = cls(filename, schema_as_string, schema, file_format, name, check_prerelease)
+        loader = cls(filename, schema_as_string, schema, file_format, name)
         return loader._load()
 
     def _load(self):
@@ -122,7 +119,7 @@ def _load(self):
             saved_attr = self._schema.header_attributes
             saved_format = self._schema.source_format
             try:
-                base_version = load_schema_version(self._schema.with_standard, check_prerelease=self.check_prerelease)
+                base_version = load_schema_version(self._schema.with_standard)
             except HedFileError as e:
                 raise HedFileError(
                     HedExceptions.SCHEMA_LIBRARY_INVALID,