Load and wire validator plugins; identify them in reports; improve test file handling

Loading and wiring:
- validate.py: add load_validation_plugins(), thread plugin_validators
  into validate_test_resources() and validate_transform_output()
- postprocess.py: instantiate plugin validators at startup, pass them
  through the validate/transform calls; delete legacy .transforms-sandbox
  on startup instead of renaming it (venvs have hardcoded absolute
  shebangs that break on rename); fix missing _rel import; add shutil import
- validation/plugin.py: PluginValidator class — subprocess-based
  execution, per-class venv management, mime-type/extension matching

Plugin identification in reports:
- Every entry emitted by a plugin now carries payload['plugin'] =
  'module.ClassName', making the source identifiable in all report formats
- validation/__init__.py: write_text() groups PLUGIN section entries with
  '--- Plugin: ... ---' sub-headers on class transitions
- report.html.mako: render a per-plugin heading in the Plugin section
  using a mutable state container to track transitions across loop
  iterations; fix subsection lookup (payload keys are top-level in the
  template dict, not nested under 'payload')

Test file handling improvements:
- validate.py: replace the hard-coded .json/.jsonld/.ttl extension filter
  for tests/ directory files with fn.is_file() — validators self-filter
  via _matches(); files no validator claims are silently dropped
- Remove the same extension filter from tests.yaml extra resources
- Add media-type field support for tests.yaml entries, allowing explicit
  MIME type declaration when the file extension is ambiguous or absent
- tests.schema.yaml: document the new media-type property

Author: avillar

ogc/bblocks/postprocess.py

@@ -1,13 +1,15 @@
 from __future__ import annotations
 
+import copy
 import itertools
 import json
 import logging
 import os.path
 import re
+import shutil
 import subprocess
 import sys
-from ogc.bblocks.sandbox import SANDBOX_DIR_NAME
+from ogc.bblocks.sandbox import SANDBOX_DIR_NAME, _OLD_SANDBOX_DIR_NAME
 from argparse import ArgumentParser
 import datetime
 from pathlib import Path
@@ -28,8 +30,8 @@
     PathOrUrl, get_git_repo_url, load_yaml
 from ogc.bblocks.schema import annotate_schema, resolve_all_schema_references, write_annotated_schema
 from ogc.bblocks.models import BuildingBlock, BuildingBlockRegister, ImportedBuildingBlocks, BuildingBlockError
-from ogc.bblocks.validate import validate_test_resources, write_report
-from ogc.bblocks.transform import apply_transforms, load_transform_plugins, transformers, cleanup_sandbox
+from ogc.bblocks.validate import validate_test_resources, write_report, load_validation_plugins
+from ogc.bblocks.transform import _rel, apply_transforms, load_transform_plugins, transformers, cleanup_sandbox
 from ogc.bblocks.permissions import check_permissions
 
 
@@ -58,7 +60,11 @@ def postprocess(registered_items_path: str | Path = 'registereditems',
 
     cwd = Path().resolve()
 
+    old_sandbox = Path(_OLD_SANDBOX_DIR_NAME)
     sandbox_dir = Path(SANDBOX_DIR_NAME)
+    if old_sandbox.is_dir():
+        logger.info("Removing legacy sandbox %s", _OLD_SANDBOX_DIR_NAME)
+        shutil.rmtree(old_sandbox, ignore_errors=True)
     sandbox_dir.mkdir(exist_ok=True)
     gitignore = sandbox_dir / '.gitignore'
     if not gitignore.exists():
@@ -67,13 +73,15 @@ def postprocess(registered_items_path: str | Path = 'registereditems',
     if skip_permissions:
         allowed_transform_types = None
         allowed_plugin_modules = None
+        allowed_validator_modules = None
     else:
-        allowed_transform_types, allowed_plugin_modules = check_permissions(
+        allowed_transform_types, allowed_plugin_modules, allowed_validator_modules = check_permissions(
             sandbox_dir, registered_items_path if isinstance(registered_items_path, Path)
             else Path(registered_items_path),
         )
 
     transform_plugins = load_transform_plugins(sandbox_dir, allowed_modules=allowed_plugin_modules)
+    plugin_validators = load_validation_plugins(sandbox_dir, allowed_modules=allowed_validator_modules)
 
     if not isinstance(test_outputs_path, Path):
         test_outputs_path = Path(test_outputs_path)
@@ -151,6 +159,27 @@ def do_postprocess(bblock: BuildingBlock, light: bool = False) -> bool:
             bblock.metadata.pop('dateOfLastChange', None)
 
         output_file_root = Path(output_file).resolve().parent
+
+        # Snapshot metadata with local paths re-anchored to cwd before the
+        # with_base_url block rewrites everything to published URLs.
+        _snap = copy.deepcopy(bblock.metadata)
+        for _field in ('ldContext', 'schema', 'openAPIDocument'):
+            _v = _snap.get(_field)
+            if _v and isinstance(_v, str) and not is_url(_v):
+                _snap[_field] = _rel(bblock.files_path / _v, cwd)
+        _shapes = _snap.get('shaclRules') or _snap.get('shaclShapes')
+        if isinstance(_shapes, list):
+            _key = 'shaclRules' if 'shaclRules' in _snap else 'shaclShapes'
+            _snap[_key] = [
+                _rel(bblock.files_path / s, cwd) if isinstance(s, str) and not is_url(s) else s
+                for s in _shapes
+            ]
+        for _r in _snap.get('resources', []):
+            _ref = _r.get('ref')
+            if _ref and not is_url(_ref):
+                _r['ref'] = _rel(bblock.files_path / _ref, cwd)
+        bblock.pre_baseurl_metadata = _snap
+
         if bblock.annotated_schema.is_file():
             schema_url_yaml = PathOrUrl(bblock.annotated_schema).with_base_url(
                 base_url, cwd if base_url else output_file_root
@@ -234,7 +263,8 @@ def do_postprocess(bblock: BuildingBlock, light: bool = False) -> bool:
                     bblock,
                     bblocks_register=bbr,
                     outputs_path=test_outputs_path,
-                    base_url=base_url)
+                    base_url=base_url,
+                    plugin_validators=plugin_validators)
                 validation_reports.append(json_report)
 
                 bblock.metadata['validationPassed'] = validation_passed
@@ -480,7 +510,8 @@ def do_postprocess(bblock: BuildingBlock, light: bool = False) -> bool:
                                      id_prefix=id_prefix,
                                      imported_register_urls=imported_registers,
                                      transform_plugins=transform_plugins,
-                                     allowed_transform_types=allowed_transform_types)
+                                     allowed_transform_types=allowed_transform_types,
+                                     plugin_validators=plugin_validators)
 
     if filter_id is None:
         cleanup_sandbox(sandbox_dir, child_bblocks)

ogc/bblocks/schemas/tests.schema.yaml

@@ -31,3 +31,9 @@ items:
         Explicit ATS test method description. When absent, the standard generator infers the method
         from the file extension. When present, this text is used verbatim in the generated ATS entry.
       type: string
+    media-type:
+      description: |
+        Explicit MIME type for this test resource. When absent, the media type is inferred from the
+        file extension. Useful for files whose extension does not map to a standard MIME type, or
+        when a validator plugin requires a specific type that differs from the default mapping.
+      type: string

ogc/bblocks/validate.py

@@ -19,8 +19,13 @@
 from ogc.bblocks.validation import Validator, ValidationItemSourceType, ValidationReportSection, ValidationItemSource, \
     ValidationReportEntry, ValidationReportItem
 from ogc.bblocks.validation.json_ import JsonValidator
+from ogc.bblocks.validation.plugin import PluginValidator
 from ogc.bblocks.validation.rdf import RdfValidator
 
+import logging
+
+logger = logging.getLogger(__name__)
+
 OUTPUT_SUBDIR = 'output'
 FORMAT_ALIASES = {
     'turtle': 'ttl',
@@ -31,6 +36,72 @@
 DEFAULT_UPLIFT_FORMATS = ['jsonld', 'ttl']
 
 
+def load_validation_plugins(sandbox_dir: Path,
+                            allowed_modules: set[str] | None = None) -> list[PluginValidator]:
+    """Read validator plugin config, create per-plugin venvs, and return PluginValidator instances.
+
+    Reads from ``plugins.validators`` in bblocks-config.yaml.
+    allowed_modules: if provided, only install/register modules in this set. Pass None to allow all.
+    """
+    from ogc.bblocks.transform import read_plugin_entries
+
+    plugin_entries = read_plugin_entries('validators')
+    if not plugin_entries:
+        return []
+
+    result: list[PluginValidator] = []
+
+    for plugin in plugin_entries:
+        pip_deps = plugin.get('pip', [])
+        if isinstance(pip_deps, str):
+            pip_deps = [pip_deps]
+
+        modules = plugin.get('modules', [])
+        if isinstance(modules, str):
+            modules = [modules]
+
+        for module_path in modules:
+            if allowed_modules is not None and module_path not in allowed_modules:
+                logger.info("Skipping validator plugin '%s': not permitted by user", module_path)
+                continue
+
+            if pip_deps:
+                logger.info("Installing validator plugin pip dependencies for '%s': %s",
+                            module_path, pip_deps)
+            else:
+                logger.info("Setting up validator plugin venv for '%s'", module_path)
+            venv_dir = PluginValidator.ensure_venv_for(pip_deps, sandbox_dir)
+
+            discovered = PluginValidator.discover(venv_dir, module_path)
+            if discovered is None:
+                raise RuntimeError(
+                    f"Validator plugin '{module_path}' could not be loaded — "
+                    "check that the module path is correct and all pip dependencies are declared"
+                )
+            if not discovered:
+                logger.warning("No validator classes found in plugin '%s'", module_path)
+                continue
+
+            for entry in discovered:
+                mime_types = entry.get('mime_types', [])
+                file_extensions = entry.get('file_extensions', [])
+                if not mime_types and not file_extensions:
+                    continue
+                pv = PluginValidator(
+                    module_path=module_path,
+                    class_name=entry['class'],
+                    pip_deps=pip_deps,
+                    sandbox_dir=sandbox_dir,
+                    mime_types=mime_types,
+                    file_extensions=file_extensions,
+                )
+                logger.info("Registered validator plugin '%s' (%s) for mime_types=%s extensions=%s",
+                            module_path, entry['class'], mime_types, file_extensions)
+                result.append(pv)
+
+    return result
+
+
 def report_to_dict(bblock: BuildingBlock,
                    items: Sequence[ValidationReportItem] | None,
                    base_url: str | None = None) -> dict:
@@ -158,7 +229,7 @@ def write_report(json_reports: list[dict],
 def _validate_resource(bblock: BuildingBlock,
                        filename: Path,
                        output_filename: Path,
-                       validators: list[Validator],
+                       validators: list,
                        resource_contents: str | None = None,
                        additional_shacl_closures: list[str | Path] | None = None,
                        base_uri: str | None = None,
@@ -167,7 +238,9 @@ def _validate_resource(bblock: BuildingBlock,
                        resource_url: str | None = None,
                        example_index: tuple[int, int] | None = None,
                        prefixes: dict[str, str] | None = None,
-                       file_format: str | None = None) -> ValidationReportItem | None:
+                       file_format: str | None = None,
+                       bblocks_register: BuildingBlockRegister | None = None,
+                       validation_resources: list[dict] | None = None) -> ValidationReportItem | None:
     if require_fail is None:
         require_fail = filename.stem.endswith('-fail') and not example_index
 
@@ -203,7 +276,10 @@ def _validate_resource(bblock: BuildingBlock,
                                         schema_ref=schema_ref,
                                         prefixes=prefixes,
                                         file_format=file_format,
-                                        resource_url=resource_url)
+                                        resource_url=resource_url,
+                                        bblock=bblock,
+                                        bblocks_register=bblocks_register,
+                                        validation_resources=validation_resources)
             any_validator_run = any_validator_run or (result is not False)
 
     except Exception as unknown_exc:
@@ -245,6 +321,7 @@ def validate_transform_output(
         transform_id: str,
         output_file: Path,
         profile_output_base: Path,
+        plugin_validators: list[PluginValidator] = (),
 ) -> ValidationReportItem:
     """Validate a transform output file against a profile building block.
 
@@ -259,6 +336,7 @@ def validate_transform_output(
     validators = [
         JsonValidator(profile_bblock, bblocks_register),
         RdfValidator(profile_bblock, bblocks_register),
+        *plugin_validators,
     ]
 
     mime_type = mimetypes.from_extension(output_file.suffix[1:]) if output_file.suffix else None
@@ -276,6 +354,9 @@ def validate_transform_output(
             validator.validate(
                 output_file, profile_output_base, report,
                 file_format=mime_type,
+                bblock=profile_bblock,
+                bblocks_register=bblocks_register,
+                validation_resources=profile_bblock.validation_resources,
             )
     except Exception as unknown_exc:
         report.add_entry(ValidationReportEntry(
@@ -295,7 +376,8 @@ def validate_transform_output(
 def validate_test_resources(bblock: BuildingBlock,
                             bblocks_register: BuildingBlockRegister,
                             outputs_path: Path | None = None,
-                            base_url: str | None = None) -> tuple[bool, int, dict]:
+                            base_url: str | None = None,
+                            plugin_validators: list[PluginValidator] = ()) -> tuple[bool, int, dict]:
     final_result = True
     test_count = 0
 
@@ -313,12 +395,13 @@ def validate_test_resources(bblock: BuildingBlock,
     validators = [
         JsonValidator(bblock, bblocks_register),
         RdfValidator(bblock, bblocks_register),
+        *plugin_validators,
     ]
 
     # Test resources
     if bblock.tests_dir.is_dir():
         for fn in sorted(bblock.tests_dir.resolve().iterdir()):
-            if fn.suffix not in ('.json', '.jsonld', '.ttl'):
+            if not fn.is_file():
                 continue
             output_fn = output_dir / fn.name
             output_base_filenames.add(fn.stem)
@@ -328,19 +411,22 @@ def validate_test_resources(bblock: BuildingBlock,
                 filename=fn,
                 output_filename=output_fn,
                 validators=validators,
+                bblocks_register=bblocks_register,
+                validation_resources=bblock.validation_resources,
             )
             if test_result:
                 all_results.append(test_result)
                 final_result = not test_result.failed and final_result
                 test_count += 1
 
     for extra_test_resource in bblock.get_extra_test_resources():
-        if not re.search(r'\.(json(ld)?|ttl)$', extra_test_resource['output-filename']):
-            continue
         fn = bblock.files_path / 'tests' / extra_test_resource['output-filename']
         output_fn = output_dir / fn.name
         output_base_filenames.add(fn.stem)
 
+        declared_media_type = extra_test_resource.get('media-type')
+        file_format = declared_media_type or (mimetypes.from_extension(fn.suffix[1:]) if fn.suffix else None)
+
         test_result = _validate_resource(
             bblock=bblock,
             filename=fn,
@@ -349,7 +435,9 @@ def validate_test_resources(bblock: BuildingBlock,
             resource_contents=extra_test_resource['contents'],
             require_fail=extra_test_resource.get('require-fail', False),
             resource_url=extra_test_resource['ref'] if isinstance(extra_test_resource['ref'], str) else None,
-            file_format=mimetypes.from_extension(fn.suffix[1:]),
+            file_format=file_format,
+            bblocks_register=bblocks_register,
+            validation_resources=bblock.validation_resources,
         )
         if test_result:
             all_results.append(test_result)
@@ -406,6 +494,8 @@ def validate_test_resources(bblock: BuildingBlock,
                     prefixes=example.get('prefixes'),
                     file_format=snippet_language,
                     additional_shacl_closures=snippet.get('shacl-closure'),
+                    bblocks_register=bblocks_register,
+                    validation_resources=bblock.validation_resources,
                 )
                 if example_result:
                     all_results.append(example_result)

ogc/bblocks/validation/__init__.py

@@ -45,6 +45,7 @@ class ValidationReportSection(Enum):
     TURTLE = 'Turtle'
     SHACL = 'SHACL'
     SEMANTIC_UPLIFT = 'Semantic Uplift'
+    PLUGIN = 'Plugin'
     UNKNOWN = 'Unknown errors'
 
 
@@ -99,7 +100,13 @@ def write_text(self, bblock: BuildingBlock, report_fn: Path):
                 if not entries:
                     continue
                 f.write(f"=== {section.value} ===\n")
+                current_plugin = None
                 for entry in entries:
+                    if section == ValidationReportSection.PLUGIN:
+                        plugin = (entry.payload or {}).get('plugin')
+                        if plugin != current_plugin:
+                            current_plugin = plugin
+                            f.write(f"\n--- Plugin: {plugin or '(unknown)'} ---\n")
                     if entry.is_error:
                         f.write("\n** Validation error **\n")
                     f.write(f"{entry.message}\n")