licomp-toolkit 0.6.3__py3-none-any.whl

licomp_toolkit/__main__.py

@@ -0,0 +1,322 @@
+#!/bin/env python3
+
+# SPDX-FileCopyrightText: 2024 Henrik Sandklef
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import json
+from json.decoder import JSONDecodeError
+import logging
+import sys
+
+from licomp.interface import LicompException
+
+from licomp_toolkit.return_codes import LicompToolkitReturnCodes
+from licomp_toolkit.toolkit import LicompToolkit
+from licomp_toolkit.toolkit import ExpressionExpressionChecker
+from licomp_toolkit.format import LicompToolkitFormatter
+from licomp_toolkit.config import cli_name
+from licomp_toolkit.config import description
+from licomp_toolkit.config import module_name
+from licomp_toolkit.config import licomp_toolkit_file_version
+from licomp_toolkit.config import epilog
+from licomp_toolkit.schema_checker import LicompToolkitSchemaChecker
+from licomp_toolkit.suggester import OutboundSuggester
+from licomp_toolkit.display_compatibility import DisplayCompatibility
+from licomp_toolkit.utils import resources_to_use
+from licomp_toolkit.utils import default_resources
+from licomp_toolkit.license_policy import LicensePolicyHandler
+
+from licomp.main_base import LicompParser
+from licomp.interface import UseCase
+from licomp.interface import Provisioning
+from licomp.return_codes import ReturnCodes
+from licomp.return_codes import compatibility_status_to_returncode
+
+from flame.license_db import FossLicenses
+from flame.exception import FlameException
+
+class LicompToolkitParser(LicompParser):
+
+    def __init__(self, name, description, epilog, default_usecase, default_provisioning):
+        self.licomp_toolkit = LicompToolkit()
+        LicompParser.__init__(self, self.licomp_toolkit, name, description, epilog, default_usecase, default_provisioning)
+        self.flame = FossLicenses()
+
+    def __normalize_license(self, lic_name):
+        return self.flame.expression_license(lic_name, update_dual=False)['identified_license']
+
+    def validate(self, args):
+        LicompToolkitSchemaChecker().validate_file(args.file_name, deep=True)
+        return None, ReturnCodes.LICOMP_OK.value, None
+
+    def _read_report_file(self, report_file):
+        try:
+            with open(report_file) as fp:
+                report = json.load(fp)
+                meta = report['meta']
+                meta_OK = meta['tool'] == module_name
+                meta_OK = meta['file_version'] == licomp_toolkit_file_version
+                file_OK = meta['file'] == 'verification'
+                if not (meta_OK and file_OK):
+                    err_msg = f'File "{report_file}" not in Licomp Toolkit\'s license policy format.'
+                    err_code = LicompToolkitReturnCodes.LICOMP_TOOLKIT_INVALID_FILE.value
+                    return None, err_code, err_msg
+                return report, ReturnCodes.LICOMP_OK.value, None
+        except (FileNotFoundError, JSONDecodeError):
+            err_msg = f'File "{report_file}" not found or not in JSON format'
+            err_code = LicompToolkitReturnCodes.LICOMP_TOOLKIT_INVALID_FILE.value
+            return None, err_code, err_msg
+        except (KeyError):
+            err_msg = f'File "{report_file}" not in Licomp Toolkit\'s license policy format.'
+            err_code = LicompToolkitReturnCodes.LICOMP_TOOLKIT_INVALID_FILE.value
+            return None, err_code, err_msg
+
+    def apply_license_policy(self, args):
+        report, err_code, err_msg = self._read_report_file(args.report_file)
+        if err_code != ReturnCodes.LICOMP_OK.value:
+            return None, err_code, err_msg
+        if args.resources:
+            logging.warning(f'User specified resources are ignored. Using the resources as specified in the report file ("{args.report_file}").')
+        resources = report['resources']
+        usecase = report['usecase']
+        provisioning = report['provisioning']
+        lph = LicensePolicyHandler(policy_file=args.license_policy_file,
+                                   resources=resources,
+                                   usecase=usecase,
+                                   provisioning=provisioning)
+        policy_report = lph.apply_policy(report, ignore_missing=True)
+        ret_code = compatibility_status_to_returncode(policy_report['compatibility'])
+        formatter = LicompToolkitFormatter.formatter(self.args.output_format)
+        formatted_report = formatter.format_policy_report(report, verbose=args.verbose)
+        return formatted_report, ret_code, False
+
+    def verify(self, args):
+        formatter = LicompToolkitFormatter.formatter(self.args.output_format)
+        try:
+            if args.no_verbose:
+                detailed_report = False
+            else:
+                detailed_report = True
+
+            resources, unsupported = resources_to_use(args)
+            if unsupported:
+                return f'Resource(s) {", ".join(unsupported)} is/are not supported', ReturnCodes.LICOMP_UNSUPPORTED_RESOURCE.value, True
+            expr_checker = ExpressionExpressionChecker()
+            compatibilities = expr_checker.check_compatibility(self.__normalize_license(args.out_license),
+                                                               self.__normalize_license(args.in_license),
+                                                               args.usecase,
+                                                               args.provisioning,
+                                                               resources=resources,
+                                                               detailed_report=detailed_report)
+
+            ret_code = compatibility_status_to_returncode(compatibilities['compatibility'])
+            if args.apply_license_policy:
+                if args.license_policy_file:
+                    lph = LicensePolicyHandler(policy_file=args.license_policy_file)
+                else:
+                    resources, unsupported = resources_to_use(args)
+                    if unsupported:
+                        return f'Resource(s) {", ".join(unsupported)} is/are not supported', ReturnCodes.LICOMP_UNSUPPORTED_RESOURCE.value, True
+                    lph = LicensePolicyHandler(resources=resources,
+                                               usecase=args.usecase,
+                                               provisioning=args.provisioning)
+                policy_report = lph.apply_policy(compatibilities)
+                return formatter.format_policy_report(policy_report, verbose=args.verbose), ret_code, False
+            else:
+                return formatter.format_compatibilities(compatibilities, verbose=args.verbose), ret_code, False
+        except LicompException as e:
+            return e, e.return_code.value, True
+        except FlameException as e:
+            return f'Illegal or missing license(s) supplied. Original message: {e}', ReturnCodes.LICOMP_ILLEGAL_LICENSE.value, True
+
+    def supported_licenses(self, args):
+        licenses = self.licomp_toolkit.supported_licenses()
+        formatter = LicompToolkitFormatter.formatter(args.output_format)
+        return formatter.format_licomp_resources(licenses), ReturnCodes.LICOMP_OK.value, None
+
+    def supported_usecases(self, args):
+        usecases = self.licomp_toolkit.supported_usecases()
+        usecase_names = [UseCase.usecase_to_string(x) for x in usecases]
+        return usecase_names, ReturnCodes.LICOMP_OK.value, None
+
+    def supported_provisionings(self, args):
+        provisionings = self.licomp_toolkit.supported_provisionings()
+        provisioning_names = [Provisioning.provisioning_to_string(x) for x in provisionings]
+        provisioning_names = list(provisioning_names)
+        provisioning_names.sort()
+        return provisioning_names, ReturnCodes.LICOMP_OK.value, None
+
+    def simplify(self, args):
+        formatter = LicompToolkitFormatter.formatter(args.output_format)
+        normalized = self.__normalize_license(' ' .join(args.license))
+        simplified = self.licomp_toolkit.simplify(normalized)
+        return formatter.format_licomp_licenses(simplified), ReturnCodes.LICOMP_OK.value, None
+
+    def supported_resources(self, args):
+        formatter = LicompToolkitFormatter.formatter(args.output_format)
+        return formatter.format_licomp_resources(self.licomp_toolkit.licomp_resources_long()), ReturnCodes.LICOMP_OK.value, False
+
+    def _supports_helper(self, key, value, output_format):
+        licomp_resources = [x for x in self.licomp_toolkit.licomp_resources_long() if value in x[key]]
+        formatter = LicompToolkitFormatter.formatter(output_format)
+        return formatter.format_licomp_resources(licomp_resources)
+
+    def supports_license(self, args):
+        lic = args.license
+        if lic not in self.licomp_toolkit.supported_licenses():
+            return None, ReturnCodes.LICOMP_UNSUPPORTED_LICENSE.value, f'License "{args.license}" not supported.'
+        return self._supports_helper('licenses', lic, args.output_format), ReturnCodes.LICOMP_OK.value, None
+
+    def supports_usecase(self, args):
+        usecase = args.usecase
+        if usecase not in [UseCase.usecase_to_string(x) for x in self.licomp_toolkit.supported_usecases()]:
+            return None, ReturnCodes.LICOMP_UNSUPPORTED_USECASE.value, f'Use case "{args.usecase}" not supported. Supported use cases: {self.supported_usecases(args)[0]}'
+        return self._supports_helper('usecases', usecase, args.output_format), ReturnCodes.LICOMP_OK.value, None
+
+    def supports_provisioning(self, args):
+        provisioning = args.provisioning
+        if provisioning not in [Provisioning.provisioning_to_string(x) for x in self.licomp_toolkit.supported_provisionings()]:
+            return None, ReturnCodes.LICOMP_UNSUPPORTED_PROVISIONING.value, f'Provisioning "{args.provisioning}" not supported. Supported provisionings: {self.supported_provisionings(args)[0]}'
+        return self._supports_helper('provisionings', provisioning, args.output_format), ReturnCodes.LICOMP_OK.value, None
+
+    def outbound_candidate(self, args):
+        suggester = OutboundSuggester()
+        licenses_to_check = None
+        if args.all_licenses:
+            licenses_to_check = self.licomp_toolkit.supported_licenses()
+
+        resources, unsupported = resources_to_use(args)
+        if unsupported:
+            return f'Resource(s) {", ".join(unsupported)} is/are not supported', ReturnCodes.LICOMP_UNSUPPORTED_RESOURCE.value, True
+        candidates = suggester.compat_licenses(args.license_expression,
+                                               args.usecase,
+                                               args.provisioning,
+                                               licenses_to_check,
+                                               resources)
+        if args.least_compatible:
+            candidates.reverse()
+
+        formatter = LicompToolkitFormatter.formatter(args.output_format)
+
+        return formatter.format_licomp_licenses(candidates), ReturnCodes.LICOMP_OK.value, None
+
+    def display_compatibility(self, args):
+        display_compat = DisplayCompatibility(self.licomp_toolkit)
+        resources, unsupported = resources_to_use(args)
+        if unsupported:
+            return f'Resource(s) {", ".join(unsupported)} is/are not supported', ReturnCodes.LICOMP_UNSUPPORTED_RESOURCE.value, True
+        compats = display_compat.display_compatibility(args.licenses,
+                                                       UseCase.string_to_usecase(args.usecase),
+                                                       Provisioning.string_to_provisioning(args.provisioning),
+                                                       resources)
+        formatter = LicompToolkitFormatter.formatter(args.output_format)
+        formatted = formatter.format_display_compatibilities(compats,
+                                                             {'discard_unsupported': args.discard_unsupported_licenses})
+        return formatted, ReturnCodes.LICOMP_OK.value, None
+
+    def versions(self, args):
+        formatter = LicompToolkitFormatter.formatter(args.output_format)
+        return formatter.format_licomp_versions(self.licomp_toolkit.versions()), ReturnCodes.LICOMP_OK.value, False
+
+
+def _working_return_code(return_code):
+    return return_code >= 0 and return_code < LicompToolkitReturnCodes.LICOMP_TOOLKIT_LAST_ERROR_CODE.value
+
+def main():
+    logging.debug("Licomp Toolkit")
+
+    lct_parser = LicompToolkitParser(cli_name,
+                                     description,
+                                     epilog,
+                                     UseCase.LIBRARY,
+                                     Provisioning.BIN_DIST)
+
+    parser = lct_parser.parser
+    subparsers = lct_parser.sub_parsers()
+
+    parser.add_argument('-r', '--resources',
+                        type=str,
+                        action='append',
+                        help=f'use specified licomp resource. For a list use the commands \'supported-resources\'. Use \'all\' to use all. Default: {", ".join(default_resources())}',
+                        default=[])
+
+    parser.add_argument('-nv', '--no-verbose',
+                        action='store_true',
+                        help='keep compatibility report as short as possible',
+                        default=[])
+
+    parser_v = subparsers.choices['verify']
+    parser_v.add_argument("--apply-license-policy", action='store_true', help='Apply license policy', default=False)
+    parser_v.add_argument("--license-policy-file", type=str, help='License policy file. Defaults to use default license policy.', default=None)
+
+    # Commands
+    parser_si = subparsers.add_parser('simplify', help='Normalize and simplify a license expression')
+    parser_si.set_defaults(which="simplify", func=lct_parser.simplify)
+    parser_si.add_argument("license", type=str, nargs="+", help='License expression to simplify')
+
+    parser_sr = subparsers.add_parser('supported-resources', help='List all supported Licomp resources')
+    parser_sr.set_defaults(which="supported_resources", func=lct_parser.supported_resources)
+
+    parser_sl = subparsers.add_parser('supports-license', help='List the Licomp resources supporting the license')
+    parser_sl.set_defaults(which="supports_license", func=lct_parser.supports_license)
+    parser_sl.add_argument("license")
+
+    parser_su = subparsers.add_parser('supports-usecase', help='List the Licomp resources supporting the usecase')
+    parser_su.set_defaults(which="supports_usecase", func=lct_parser.supports_usecase)
+    parser_su.add_argument("usecase")
+
+    parser_sp = subparsers.add_parser('supports-provisioning', help='List the Licomp resources supporting the provisioning')
+    parser_sp.set_defaults(which="supports_provisioning", func=lct_parser.supports_provisioning)
+    parser_sp.add_argument("provisioning")
+
+    parser_dc = subparsers.add_parser('display-compatibility', help='Display the compatibility between the supplied licenses')
+    parser_dc.set_defaults(which="display_compatibility", func=lct_parser.display_compatibility)
+    parser_dc.add_argument("licenses",
+                           type=str,
+                           nargs='+',
+                           default=[])
+    parser_dc.add_argument('-dul', '--discard-unsupported-licenses',
+                           action='store_true',
+                           help='Discard unsupported licenses from the output',
+                           default=False)
+
+    parser_ob = subparsers.add_parser('outbound-candidate', help='Identify outbound candidates to a license expression')
+    parser_ob.set_defaults(which='outbound_candidate', func=lct_parser.outbound_candidate)
+    parser_ob.add_argument("license_expression")
+    parser_ob.add_argument('-al', '--all-licenses',
+                           action='store_true',
+                           help='Use all known licenses to identify outbound candidates',
+                           default=False)
+    parser_ob.add_argument('-lc', '--least-compatible',
+                           action='store_true',
+                           help='Sort the license according to least compatibility (i.e. from restrictive to permissive. Default is to list permissive to restrictive.',
+                           default=False)
+
+    # Command: list versions (of all toolkit and licomp resources)
+    parser_sr = subparsers.add_parser('versions', help='Output version of licomp-toolkit and all the licomp resources')
+    parser_sr.set_defaults(which="versions", func=lct_parser.versions)
+
+    # Command: apply policy
+    parser_sr = subparsers.add_parser('apply-license-policy', help='')
+    parser_sr.set_defaults(which="apply_license_policy", func=lct_parser.apply_license_policy)
+    parser_sr.add_argument('--license-policy-file', '-lpf', type=str, help='License policy file', default=None)
+    parser_sr.add_argument("report_file", type=str)
+
+    res, code, err, func = lct_parser.run_noexit()
+    if _working_return_code(code):
+        if res:
+            print(res)
+        else:
+            if err:
+                print(err, file=sys.stderr)
+            else:
+                pass
+    else:
+        print(res, file=sys.stderr)
+
+    return code
+
+
+if __name__ == '__main__':
+    sys.exit(main())

licomp_toolkit/config.py

@@ -0,0 +1,40 @@
+# SPDX-FileCopyrightText: 2024 Henrik Sandklef
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+licomp_toolkit_version = '0.6.3'
+my_supported_api_version = '0.5'
+licomp_toolkit_file_version = '0.5'
+
+cli_name = 'licomp-toolkit'
+module_name = 'licomp_toolkit'
+
+disclaimer = 'This software and the data come with no guarantee. For more information read the disclaimers from the individual compatibility resources, and contact a lawyer to make sure your software is compliant.'
+
+description = """
+Simple command line tool to check compatibility between two licenses, given context
+"""
+
+epilog = """
+
+AUTHOR
+  Henrik Sandklef
+
+PROJECT SITE
+  https://codeberg.org/software-compliance-org/licomp-toolkit
+
+PYPI SITE
+  https://pypi.org/project/licomp-toolkit/
+
+REPORTING BUGS
+  File a ticket at https://codeberg.org/software-compliance-org/licomp-toolkit/issues
+
+COPYRIGHT
+  Copyright (c) 2024 Henrik Sandklef<hesa@sandklef.com>.
+  License GPL-3.0-or-later
+
+ATTRIBUTION
+  licomp-toolkit is using various Licomp resources. Use the command supported-resources to list them.
+
+
+"""

licomp_toolkit/data/reply_schema.json

@@ -0,0 +1,305 @@
+{
+  "$schema" : "http://json-schema.org/draft-07/schema#",
+  "$id" : "",
+  "title" : "Licomp Toolkit Reply",
+  "type" : "object",
+  "properties" : {
+    "meta": {
+      "type" : "object",
+      "properties" : {
+        "status" : {
+          "type": "string",
+          "description" : ""
+        },
+        "tool" : {
+          "type": "string",
+          "description" : ""
+        },
+        "file_version" : {
+          "type": "string",
+          "description" : ""
+        }
+      }
+    },
+    "compatibility_report": {
+      "type" : "object",
+      "$ref": "#/$defs/compatibility_object"
+    },
+    "outbound" : {
+      "$ref": "#/$defs/license",
+      "description" : "The outbound license expression."
+    },
+    "inbound" : {
+      "$ref": "#/$defs/license",
+      "description" : "The inbound license expression."
+    },
+    "usecase" : {
+      "type" : "string",
+      "enum": ["library", "compiler", "snippet", "tool", "test"],
+      "description" : "Usecase for the compatibility check, e.g. library (as in using the inbound licensed component as a library)"
+    },
+    "provisioning" : {
+      "type" : "string",
+      "enum": ["source-code-distribution", "binary-distribution", "local-use", "provide-service", "provide-webui"],
+      "description" : "The way the component is provided to the user for the compatibility check, e.g. binary-distribution"
+    },
+    "modification" : {
+      "type" : "string",
+      "description" : "Has the component been modified. Currently not used/implemented.",
+      "enum": [ "unmodified", "modified"]
+    },
+    "resources": {
+      "description": "Which resources are available, regardless of context",
+      "type": "array",
+      "items": {
+        "type" : "string"
+      }
+    },
+    "available_resources": {
+      "description": "Which resources are available given the context",
+      "type": "array",
+      "items": {
+        "type" : "string"
+      }
+    },
+    "unavailable_resources": {
+      "description": "Which resources are not available given the context",
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "resource": {
+            "type": "string",
+            "description": "The resource name"
+},
+          "reasons": {
+            "type": "string",
+            "description": "The reason the resource is not available" }
+        }
+      }
+    },
+    "compatibility" : {
+      "$ref": "#/$defs/compatibility",
+      "description" : "The inbound license expression."
+    }
+  },
+  "required" : [ "compatibility_report", "compatibility", "outbound", "inbound" , "usecase", "resources", "unavailable_resources", "available_resources" ],
+  "additionalProperties" : false,
+  "$defs": {
+    "compatibility_object": {
+      "type" : "object",
+      "oneOf": [
+        {
+          "properties": {
+            "compatibility": {
+              "$ref": "#/$defs/compatibility",
+              "description" : "The inbound license expression."
+            },
+            "compatibility_check": {
+              "$ref": "#/$defs/compatibility_check"
+            },
+            "check_class": {
+              "type": "string",
+              "description": "Names the class/function used to determine. For development purposes"
+            },
+            "inbound_license": {
+              "$ref": "#/$defs/license",
+              "description" : "The inbound license expression."
+            },
+            "outbound_license": {
+              "$ref": "#/$defs/license",
+              "description" : "The outbound license expression."
+            },
+            "compatibility_details": {
+              "oneOf": [
+                {
+                  "type": "object",
+                  "properties": {
+                    "compatibilities": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/$defs/licomp_object"
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "compatibility_object": {
+              "type" : "object",
+              "anyOf": [
+                {
+                  "$ref": "#/$defs/compatibility_object"
+                },
+                {
+                  "properties": {}
+                }
+              ]
+            }
+          },
+          "required": [ "compatibility", "compatibility_check", "inbound_license" , "outbound_license", "compatibility_object", "compatibility_details"],
+          "additionalProperties" : false
+        },
+        {
+          "properties": {
+            "compatibility" : {
+              "$ref": "#/$defs/compatibility",
+              "description" : "The inbound license expression."
+            },
+            "compatibility_check": {
+              "$ref": "#/$defs/compatibility_check"
+            },
+            "check_class": {
+              "type": "string",
+              "description": "Names the class/function used to determine. For development purposes"
+            },
+            "inbound_license": {
+              "$ref": "#/$defs/license",
+              "description" : "The inbound license expression."
+            },
+            "outbound_license": {
+              "$ref": "#/$defs/license",
+              "description" : "The inbound license expression."
+            },
+            "compatibility_details": {
+              "type": "null"
+            },
+            "operator": {
+              "enum": [ "AND", "OR" ],
+              "description" : "The logical operator between two license expressions."
+            },
+            "operands": {
+              "type": "array",
+              "items": {
+                "compatibility_object": {
+                  "type" : "object",
+                  "$ref": "#/$defs/compatibility_object"
+                },
+                "compatibility": { "type": "string" }
+              },
+              "description": "The operands for the operator. The operands can be either a license or an operator."
+            }
+          },
+          "required": [ "compatibility", "compatibility_check", "inbound_license" , "outbound_license" , "operator", "operands" ],
+          "additionalProperties" : false
+        }
+      ]
+    },
+    "compatibility" : {
+      "type" : "string",
+      "enum": [ "yes", "no", "depends", "unknown", "unsupported", "mixed", null],
+      "description" : "The compatbility between the Outbound and Inbound license expressions"
+    },
+    "license" : {
+      "type" : "string",
+      "minLength": 1
+    },
+    "compatibility_check": {
+      "type": "string",
+      "enum": [
+        "outbound-expression -> inbound-expression",
+        "outbound-expression -> inbound-license",
+        "outbound-license -> inbound-expression",
+        "outbound-license -> inbound-license"
+      ],
+      "description" : "A text describing if outbound license or expression is checked for compatiblility against inbound license or expression."
+    },
+    "licomp_object": {
+      "type" : "object",
+      "properties" : {
+        "status" : {
+          "enum": [ "failure", "success" ],
+          "description" : "Overall status indicating if the compatibility check succeeded."
+        },
+        "status_details" : {
+          "type" : "object",
+          "properties" : {
+	    "provisioning_status": {
+	      "enum": [ "failure", "success" ],
+              "description" : "Status indicating if the provisioning is supported."
+	    },
+	    "usecase_status": {
+	      "enum": [ "failure", "success" ],
+              "description" : "Status indicating if the usecase is supported."
+	    },
+	    "license_supported_status": {
+	      "enum": [ "failure", "success" ],
+              "description" : "Status indicating if the licenses are supported."
+	    }
+          }
+        },
+        "outbound" : {
+          "type" : "string",
+          "minLength": 1,
+          "description" : "The outbound license"
+        },
+        "inbound" : {
+          "type" : "string",
+          "minLength": 1,
+          "description" : "The inbound license"
+        },
+        "usecase" : {
+          "type" : "string",
+          "enum": ["library", "compiler", "snippet", "tool", "test"],
+          "description" : "Usecase for the compatibility check, e.g. library (as in using the inbound licensed component as a library)"
+        },
+        "provisioning" : {
+          "type" : "string",
+          "enum": ["source-code-distribution", "binary-distribution", "local-use", "provide-service", "provide-webui"],
+          "description" : "The way the component is provided to the user for the compatibility check, e.g. binary-distribution"
+        },
+        "modification" : {
+          "type" : "string",
+          "description" : "Has the component been modified. Currently not used/implemented.",
+          "enum": [ "unmodified", "modified"]
+        },
+        "compatibility_status" : {
+          "enum": [ "yes", "no", "depends", "unknown", "unsupported", null],
+          "description" : "The compatbility between the Outbound and Inbound license expressions"
+        },
+        "explanation" : {
+          "type" : "array" ,
+          "items": {
+            "type" : "string"
+          },
+          "description" : "A list of texts describing the compatiblity, e.g. how the compatibility was determined"
+        },
+        "api_version" : {
+          "type" : "string",
+          "pattern": "^[0-9].[0-9](.[0-9]){0,1}$",
+          "description" : "The api version of the program providing the reply"
+        },
+        "resource_name" : {
+          "type" : "string",
+          "minLength": 1,
+          "description" : "The name of the program providing the reply, e.g. licomp-osadl"
+        },
+        "resource_version" : {
+          "type" : "string",
+          "pattern": "^[0-9].[0-9](.[0-9]){0,1}$",
+          "description" : "The versions of the program providing the reply, e.g. licomp-osadl"
+        },
+        "resource_disclaimer" : {
+          "type" : "string",
+          "minLength": 10,
+          "description" : "A disclaimer of the program providing the reply."
+        },
+        "data_url" : {
+          "type" : "string",
+          "minLength": 10,
+          "description" : "A URL pointing to the data used to provide the resulting compatibility."
+        },
+        "resource_url" : {
+          "type" : "string",
+          "minLength": 10,
+          "description" : "A URL pointing to the project page (or similar) for the program providing the resulting compatibility."
+        }
+      },
+      "required" : [ "status", "status_details", "outbound", "inbound", "usecase", "provisioning", "modification", "compatibility_status", "explanation", "api_version", "resource_name", "resource_version", "resource_disclaimer", "data_url", "resource_url"],
+      "additionalProperties" : false  
+    }
+  }
+}