Add support to apply a license policy to the compatibility report

.reuse/dep5

@@ -27,3 +27,6 @@ Files: README.md docs/*.md
 Copyright: Henrik Sandklef
 License: GPL-3.0-or-later
 
+Files: tests/policy/license-policy.json tests/policy/bad-license-policy.json
+Copyright: Henrik Sandklef
+License: GPL-3.0-or-later

devel/licomp-toolkit

@@ -14,6 +14,13 @@ fi
 if [ "$1" = "" ]
 then
     ARGS="verify -il MIT -ol \"MIT OR X11\""
+else
+    ARGS=""
+    for arg in "$@"
+    do
+        ARGS="$ARGS \"$arg\""
+    done
 fi     
 
-echo PYTHONPATH=${EXTRA_PYTHONPATH}:${PYTHONPATH} ${SCRIPT_DIR}/licomp_toolkit/__main__.py $* $ARGS | bash
+
+echo PYTHONPATH=${EXTRA_PYTHONPATH}:${PYTHONPATH} ${SCRIPT_DIR}/licomp_toolkit/__main__.py $ARGS | bash

licomp_toolkit/__main__.py

@@ -4,21 +4,28 @@
 #
 # 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
@@ -43,6 +50,47 @@ 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:
@@ -63,7 +111,20 @@ def verify(self, args):
                                                                detailed_report=detailed_report)
 
             ret_code = compatibility_status_to_returncode(compatibilities['compatibility'])
-            return formatter.format_compatibilities(compatibilities), ret_code, False
+            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:
@@ -125,11 +186,14 @@ def outbound_candidate(self, args):
         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,
-                                               args.resources)
+                                               resources)
         if args.least_compatible:
             candidates.reverse()
 
@@ -139,10 +203,13 @@ def outbound_candidate(self, args):
 
     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),
-                                                       args.resources)
+                                                       resources)
         formatter = LicompToolkitFormatter.formatter(args.output_format)
         formatted = formatter.format_display_compatibilities(compats,
                                                              {'discard_unsupported': args.discard_unsupported_licenses})
@@ -154,7 +221,7 @@ def versions(self, args):
 
 
 def _working_return_code(return_code):
-    return return_code >= 0 and return_code < ReturnCodes.LICOMP_LAST_SUCCESSFUL_CODE.value
+    return return_code >= 0 and return_code < LicompToolkitReturnCodes.LICOMP_TOOLKIT_LAST_ERROR_CODE.value
 
 def main():
     logging.debug("Licomp Toolkit")
@@ -171,14 +238,18 @@ def main():
     parser.add_argument('-r', '--resources',
                         type=str,
                         action='append',
-                        help='use specified licomp resource. For a list use the commands \'supported-resources\'. Use \'all\' to use all',
+                        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)
@@ -226,6 +297,12 @@ def main():
     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:

licomp_toolkit/config.py

@@ -4,6 +4,7 @@
 
 licomp_toolkit_version = '0.5.18'
 my_supported_api_version = '0.5'
+licomp_toolkit_file_version = '0.5'
 
 cli_name = 'licomp-toolkit'
 module_name = 'licomp_toolkit'

licomp_toolkit/data/reply_schema.json

@@ -4,6 +4,23 @@
   "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"
@@ -78,13 +95,13 @@
               "$ref": "#/$defs/compatibility",
               "description" : "The inbound license expression."
             },
-            "compatibility_type": {
-              "enum": [ "license" ],
-              "description": "Describing what is being checked. Can be either expression or license. In this case the value is \"license\"."
-            },
             "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."
@@ -123,7 +140,7 @@
               ]
             }
           },
-          "required": [ "compatibility", "compatibility_type", "compatibility_check", "inbound_license" , "outbound_license", "compatibility_object", "compatibility_details"],
+          "required": [ "compatibility", "compatibility_check", "inbound_license" , "outbound_license", "compatibility_object", "compatibility_details"],
           "additionalProperties" : false
         },
         {
@@ -132,13 +149,13 @@
               "$ref": "#/$defs/compatibility",
               "description" : "The inbound license expression."
             },
-            "compatibility_type": {
-              "enum": [ "expression" ],
-              "description": "Describing what is being checked. Can be either expression or license. In this case the value is \"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."
@@ -166,7 +183,7 @@
               "description": "The operands for the operator. The operands can be either a license or an operator."
             }
           },
-          "required": [ "compatibility", "compatibility_type", "compatibility_check", "inbound_license" , "outbound_license" , "operator", "operands" ],
+          "required": [ "compatibility", "compatibility_check", "inbound_license" , "outbound_license" , "operator", "operands" ],
           "additionalProperties" : false
         }
       ]
@@ -255,7 +272,7 @@
           "pattern": "^[0-9].[0-9](.[0-9]){0,1}$",
           "description" : "The api version of the program providing the reply"
         },
-        "resource_name1" : {
+        "resource_name" : {
           "type" : "string",
           "minLength": 1,
           "description" : "The name of the program providing the reply, e.g. licomp-osadl"
@@ -281,7 +298,7 @@
           "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_name1", "resource_version", "resource_disclaimer", "data_url", "resource_url"],
+      "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  
     }
   }

licomp_toolkit/exception.py

@@ -0,0 +1,11 @@
+# SPDX-FileCopyrightText: 2026 Henrik Sandklef
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+class LicompToolkitException(Exception):
+
+    def __init__(self, message, error_code, orig_exception=None):
+        self.message = message
+        super().__init__(self.message)
+        self.error_code = error_code
+        self.original_exception = orig_exception

licomp_toolkit/expr_parser.py

@@ -12,8 +12,6 @@
 OR = "OR"
 
 COMPATIBILITY_TYPE = 'compatibility_type'
-COMPATIBILITY_OUTBOUND_LICENSE = 'outbound_license'
-COMPATIBILITY_INBOUND_LICENSE = 'inbound_license'
 
 class LicenseExpressionParser():
 
@@ -127,7 +125,7 @@ def __parse_expression(self, expression):
         elif self.__is_close(expression):
             return ""
 
-        raise Exception("Bottom reached")
+        raise Exception("Bottom reached in __parse_expression (expr_parser.py)")
 
     def to_string(self, parsed_license):
         license_type = parsed_license['compatibility_type']