Analysis schema

hepdata/config.py

@@ -331,9 +331,7 @@ def _(x):
         'description': 'MadAnalysis 5 analysis'
     },
     'SModelS': {
-        'endpoint_url': 'https://zenodo.org/records/13952092/files/smodels-analyses.hepdata.json?download=1',
-        'url_template': '{0}',
-        'description': 'SModelS analysis',
+        'endpoint_url': 'https://smodels.github.io/docs/smodels-analyses.hepdata.json',
         'subscribe_user_id': 7766
     },
     'CheckMATE': {

hepdata/modules/records/utils/analyses.py

@@ -23,11 +23,14 @@
 # as an Intergovernmental Organization or submit itself to any jurisdiction.
 
 import logging
+import os
 
 from celery import shared_task
 from flask import current_app
 from invenio_db import db
 import requests
+import json
+import jsonschema
 
 from hepdata.ext.opensearch.api import index_record_ids
 from hepdata.modules.submission.api import get_latest_hepsubmission, is_resource_added_to_submission
@@ -40,6 +43,11 @@
 logging.basicConfig()
 log = logging.getLogger(__name__)
 
+def test_analyses_schema(json_file, schema_version="1.0.0"):
+    schema_path = os.path.join("hepdata", "templates", "analyses_schema", schema_version, "analyses_schema.json")
+    with open(schema_path) as f:
+        schema = json.load(f)
+    jsonschema.validate(instance=json_file, schema=schema)
 
 @shared_task
 def update_analyses(endpoint=None):
@@ -50,6 +58,7 @@ def update_analyses(endpoint=None):
 
     :param endpoint: either "rivet" or "MadAnalysis" or "SModelS" or "CheckMATE" or "HackAnalysis" or "Combine" or None (default) for all
     """
+
     endpoints = current_app.config["ANALYSES_ENDPOINTS"]
     for analysis_endpoint in endpoints:
 
@@ -64,62 +73,130 @@ def update_analyses(endpoint=None):
 
             if response and response.status_code == 200:
 
-                analyses = response.json()
-
                 analysis_resources = DataResource.query.filter_by(file_type=analysis_endpoint).all()
 
-                # Check for missing analyses.
-                for record in analyses:
-                    submission = get_latest_hepsubmission(inspire_id=record, overall_status='finished')
-
-                    if submission:
-                        num_new_resources = 0
-
-                        for analysis in analyses[record]:
-                            _resource_url = endpoints[analysis_endpoint]["url_template"].format(analysis)
-
-                            if not is_resource_added_to_submission(submission.publication_recid, submission.version,
-                                                                   _resource_url):
-
-                                log.info('Adding {} analysis to ins{} with URL {}'.format(
-                                    analysis_endpoint, record, _resource_url)
-                                )
-                                new_resource = DataResource(
-                                    file_location=_resource_url,
-                                    file_type=analysis_endpoint)
-
-                                if "description" in endpoints[analysis_endpoint]:
-                                    new_resource.file_description = str(endpoints[analysis_endpoint]["description"])
+                r_json = response.json()
 
-                                if "license" in endpoints[analysis_endpoint]:
-                                    resource_license = get_license(endpoints[analysis_endpoint]["license"])
-                                    new_resource.file_license = resource_license.id
+                schema_version = "0.1.0"  # default to 0.1.0 for backward compatibility when schema_version field is missing
+                if "schema_version" in r_json:
+                    schema_version = r_json["schema_version"]
 
-                                submission.resources.append(new_resource)
-                                num_new_resources += 1
+                # Validate analyses JSON file against the schema.
+                try:
+                    test_analyses_schema(r_json, schema_version=schema_version)
+                except jsonschema.exceptions.ValidationError as e:
+                    log.error("Validation error for analyses schema {0} in {1}: {2}".format(schema_version, analysis_endpoint, e))
+                    continue
 
-                            else:
-
-                                # Remove resources from 'analysis_resources' list.
-                                resources = list(filter(lambda a: a.file_location == _resource_url, analysis_resources))
-                                for resource in resources:
-                                    analysis_resources.remove(resource)
-
-                        if num_new_resources:
-
-                            try:
-                                db.session.add(submission)
-                                db.session.commit()
-                                latest_submission = get_latest_hepsubmission(inspire_id=record)
-                                if submission.version == latest_submission.version:
-                                    index_record_ids([submission.publication_recid])
-                            except Exception as e:
-                                db.session.rollback()
-                                log.error(e)
-
-                    else:
-                        log.debug("An analysis is available in {0} but with no equivalent in HEPData (ins{1}).".format(
-                            analysis_endpoint, record))
+                if schema_version == "0.1.0":
+                    analyses = r_json
+
+                    # Check for missing analyses.
+                    for record in analyses:
+                        submission = get_latest_hepsubmission(inspire_id=record, overall_status='finished')
+
+                        if submission:
+                            num_new_resources = 0
+
+                            for analysis in analyses[record]:
+                                _resource_url = endpoints[analysis_endpoint]["url_template"].format(analysis)
+
+                                if not is_resource_added_to_submission(submission.publication_recid, submission.version,
+                                                                    _resource_url):
+
+                                    log.info('Adding {} analysis to ins{} with URL {}'.format(
+                                        analysis_endpoint, record, _resource_url)
+                                    )
+                                    new_resource = DataResource(
+                                        file_location=_resource_url,
+                                        file_type=analysis_endpoint)
+
+                                    if "description" in endpoints[analysis_endpoint]:
+                                        new_resource.file_description = str(endpoints[analysis_endpoint]["description"])
+
+                                    if "license" in endpoints[analysis_endpoint]:
+                                        resource_license = get_license(endpoints[analysis_endpoint]["license"])
+                                        new_resource.file_license = resource_license.id
+
+                                    submission.resources.append(new_resource)
+                                    num_new_resources += 1
+
+                                else:
+
+                                    # Remove resources from 'analysis_resources' list.
+                                    resources = list(filter(lambda a: a.file_location == _resource_url, analysis_resources))
+                                    for resource in resources:
+                                        analysis_resources.remove(resource)
+
+                            if num_new_resources:
+
+                                try:
+                                    db.session.add(submission)
+                                    db.session.commit()
+                                    latest_submission = get_latest_hepsubmission(inspire_id=record)
+                                    if submission.version == latest_submission.version:
+                                        index_record_ids([submission.publication_recid])
+                                except Exception as e:
+                                    db.session.rollback()
+                                    log.error(e)
+
+                        else:
+                            log.debug("An analysis is available in {0} but with no equivalent in HEPData (ins{1}).".format(
+                                analysis_endpoint, record))
+
+                else:  # schema_version >= "1.0.0"
+                    # Check for missing analyses.
+                    for ana in r_json["analyses"]:
+                        inspire_id = str(ana["inspire_id"])  # inspire_id is stored as a string in the database
+                        submission = get_latest_hepsubmission(inspire_id=inspire_id, overall_status='finished')
+
+                        if submission:
+                            num_new_resources = 0
+
+                            for implementation in ana["implementations"]:
+                                _resource_url = r_json["url_templates"]["main_url"].format(**implementation)
+
+                                if not is_resource_added_to_submission(submission.publication_recid, submission.version,
+                                                                    _resource_url):
+
+                                    log.info('Adding {} analysis to ins{} with URL {}'.format(
+                                        analysis_endpoint, inspire_id, _resource_url)
+                                    )
+                                    new_resource = DataResource(
+                                        file_location=_resource_url,
+                                        file_type=analysis_endpoint,
+                                        file_description=r_json["implementations_description"]
+                                    )
+
+                                    if "implementations_license" in r_json:
+                                        resource_license = get_license(r_json["implementations_license"])
+                                        new_resource.file_license = resource_license.id
+
+                                    submission.resources.append(new_resource)
+                                    num_new_resources += 1
+
+                                else:
+
+                                    # Remove resources from 'analysis_resources' list.
+                                    resources = list(filter(lambda a: a.file_location == _resource_url, analysis_resources))
+                                    for resource in resources:
+                                        analysis_resources.remove(resource)
+
+                            if num_new_resources:
+
+                                try:
+                                    db.session.add(submission)
+                                    db.session.commit()
+                                    latest_submission = get_latest_hepsubmission(inspire_id=inspire_id)
+                                    if submission.version == latest_submission.version:
+                                        index_record_ids([submission.publication_recid])
+                                except Exception as e:
+                                    db.session.rollback()
+                                    log.error(e)
+
+                        else:
+                            log.debug("An analysis is available in {0} but with no equivalent in HEPData (ins{1}).".format(
+                                analysis_endpoint, inspire_id))
 
                 if analysis_resources:
                     # Extra resources that were not found in the analyses JSON file.
@@ -154,10 +231,19 @@ def update_analyses(endpoint=None):
                 if "subscribe_user_id" in endpoints[analysis_endpoint]:
                     user = get_user_from_id(endpoints[analysis_endpoint]["subscribe_user_id"])
                     if user:
-                        for record in analyses:
-                            submission = get_latest_hepsubmission(inspire_id=record, overall_status='finished')
-                            if submission and not is_current_user_subscribed_to_record(submission.publication_recid, user):
-                                subscribe(submission.publication_recid, user)
+                        # Check for missing analyses.
+                        if schema_version == "0.1.0":
+                            for record in analyses:
+                                submission = get_latest_hepsubmission(inspire_id=record, overall_status='finished')
+                                if submission and not is_current_user_subscribed_to_record(submission.publication_recid, user):
+                                    subscribe(submission.publication_recid, user)
+
+                        else:  # schema_version >= "1.0.0"
+                            for ana in r_json["analyses"]:
+                                submission = get_latest_hepsubmission(inspire_id=str(ana["inspire_id"]), overall_status='finished')
+                                if submission and not is_current_user_subscribed_to_record(submission.publication_recid, user):
+                                    subscribe(submission.publication_recid, user)
+
 
         else:
-            log.debug("No endpoint url configured for {0}".format(analysis_endpoint))
+            log.debug("No endpoint_url configured for {0}".format(analysis_endpoint))

hepdata/modules/theme/views.py

@@ -25,8 +25,9 @@
 """Theme blueprint in order for template and static files to be loaded."""
 
 import re
+import json
 
-from flask import Blueprint, render_template, current_app, redirect, request, url_for
+from flask import Blueprint, render_template, current_app, redirect, request, url_for, jsonify
 from hepdata_validator import LATEST_SCHEMA_VERSION, RAW_SCHEMAS_URL
 
 from hepdata.modules.email.utils import send_flask_message_email
@@ -84,6 +85,13 @@ def submission_schema(jsonschema):
     return redirect(RAW_SCHEMAS_URL + '/' + jsonschema)
 
 
+@blueprint.route('/analyses/schemas/<path:jsonschema>')
+def analyses_schema(jsonschema):
+    with current_app.open_resource('templates/analyses_schema/' + jsonschema) as jsonfile:
+        schema = json.load(jsonfile)
+    return jsonify(schema)
+
+
 @blueprint.route('/cookies')
 def cookie_policy():
     return render_template('hepdata_theme/pages/cookies.html')

hepdata/templates/analyses_schema/0.1.0/analyses_schema.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://hepdata.net/analyses/schemas/0.1.0/analyses_schema.json",
+  "title": "HEPData analysis tool schema",
+  "description": "A JSON schema for tracking implementations of HEPData analyses in different tools",
+  "type": "object",
+  "patternProperties": {
+    "^[0-9]+$": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "minItems": 1
+    }
+  },
+  "additionalProperties": false
+}

hepdata/templates/analyses_schema/0.1.0/readme.md

@@ -0,0 +1,38 @@
+# About the analyses JSON schema
+
+This readme details a JSON schema which is used by reinterpretation tools to communicate to HEPData which analyses are implemented in that tool and where to find the implementations.
+
+## The standard
+
+The standard is quite simple: the whole file is basically a dictionary where the keys are the different INSPIRE IDs for the analyses implemented in the tool and the values are lists of tool-internal names for the reimplentations, i.e.
+```JSON
+{
+  "<INSPIRE ID>": ["<implementation 1>", "<implementation 2>"]
+}
+```
+
+No other fields are allowed.
+
+## Example
+A minimal example for an analyses JSON adhering to the standard looks like this:
+```JSON
+{
+  "100592": ["MARKI_1975_I100592", "MARKI_ALTERNATIVE_IMPLEMENTATION"],
+  "1081268": ["LHCB_2013_I1081268"]
+}
+```
+
+## Testing an implementation
+
+Whether an analyses JSON file adheres to the standard defined here, can be checked with python as follows:
+```python
+import json
+import jsonschema
+
+with open("analyses_schema.json") as f:
+  schema = json.load(f)
+with open("analyses_example.json") as f:
+  test = json.load(f)
+
+jsonschema.validate(instance=test, schema=schema)
+```