licomp-toolkit 0.6.3__py3-none-any.whl

licomp_toolkit/suggester.py

@@ -0,0 +1,162 @@
+# SPDX-FileCopyrightText: 2025 Henrik Sandklef
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import logging
+import re
+import traceback
+
+from licomp_toolkit.toolkit import LicompToolkit
+from licomp_toolkit.toolkit import ExpressionExpressionChecker
+from licomp.interface import Provisioning
+from licomp.interface import UseCase
+
+from flame.license_db import FossLicenses
+
+class OutboundSuggester:
+    """
+    OutboundSuggester suggests outbound candidate licenses from a
+    license expression
+
+    If you have a license expression like this "BSD-3-Clause AND MIT
+    AND GPL-2.0-only", typically the result of your dependencies'
+    licenses, and want to know which outbound license you can chose.
+
+    """
+    def __init__(self):
+        self._compatibility_rankings = {}
+        self.lt = LicompToolkit()
+        self.le = ExpressionExpressionChecker()
+        self.flame = FossLicenses()
+
+    def compatibility_rankings(self, usecase, provisioning):
+        """ Returns a dict with ranked licenses based on your usecase/provisioning, e.g.
+
+          {
+             'GPL3':  {'count': 2, 'valids': '1', 'index': 69},
+             'MIT':   {'count': 108, 'valids': '1', 'index': 169}
+          }
+
+          count - how many other licenses the license is compatible with (primary sort)
+          valids - how many valid resources provided a 'yes' answer (secondary sort)
+          index - index for the licenses, the higher index the more compatible (with other licenses)
+        """
+        if usecase in self._compatibility_rankings:
+            if provisioning in self._compatibility_rankings[usecase]:
+                return self._compatibility_rankings[usecase][provisioning]
+        else:
+            self._compatibility_rankings[usecase] = {}
+
+        #
+        # identify compatiblities
+        lic_map = {}
+        # loop through every license (against themselves)
+        for in_lic in self.lt.supported_licenses():
+            for out_lic in self.lt.supported_licenses():
+                # get compat
+                ret = self.lt.outbound_inbound_compatibility(out_lic,
+                                                             in_lic,
+                                                             UseCase.string_to_usecase(usecase),
+                                                             Provisioning.string_to_provisioning(provisioning))
+                results = ret['summary']['results']
+                valid_results = results['nr_valid']
+                # only increase the 'count' if the answers from the resources are only 'yes'
+                yes = results.get('yes', {'count': 0, 'percent': 0.0})
+                inc = 0
+                if yes['percent'] == 100:
+                    inc = 1
+
+                lic_map[in_lic] = {
+                    'count': lic_map.get(in_lic, {'count': 0})['count'] + inc,
+                    'valids': valid_results,
+                }
+
+        # decorate (to sort list)
+        decorated = [(lic_map[lic]['count'], lic_map[lic]['valids'], i, lic) for i, lic in enumerate(lic_map)]
+        # sort after count, valids (in tuple)
+        decorated.sort()
+        # undecorate
+        ordered_lic = [lic for count, valids, i, lic in decorated]
+
+        # create new dict - use license name as key
+        ordered_lic_map = {}
+        for i, lic in enumerate(ordered_lic):
+            ordered_lic_map[lic] = lic_map[lic]
+            ordered_lic_map[lic]['index'] = i
+
+        # store foar later (re)use
+        self._compatibility_rankings[usecase][provisioning] = ordered_lic_map
+
+        return self._compatibility_rankings[usecase][provisioning]
+
+    def licenses(self, license_expr):
+        """Returns a list of licenses in a license expression.
+
+        If you have a license expression like this:
+        "(MIT OR Apache-2.0) AND MIT AND GPL-2.0-only WITH Classpath-exception-2.0"
+
+        you get a list like this:
+        ["MIT", "Apache-2.0", "GPL-2.0-only WITH Classpath-exception-2.0"]
+
+        """
+        normalized = self.flame.expression_license(license_expr, update_dual=False)['identified_license']
+
+        with_fixed = normalized.replace(' WITH ', '-WITH-')
+
+        splits = [x.replace('-WITH-', ' WITH ') for x in re.split(r' AND | OR |\(|\)', with_fixed) if len(x) > 1]
+
+        return splits
+
+    def compat_licenses(self, license_expr, usecase, provisioning, licenses_to_check=None, resources=None):
+        """Returns a list of licenses that are compatible with a license expression
+
+        If you have a license expression like this:
+        "(MIT OR Apache-2.0) AND MIT AND GPL-2.0-only"
+
+        you get a list like this of licenses that are compatible with
+        the expression listed in order of ranked compatibility. If you
+        don't provide any licenses to check the functions defaults to
+        looking at the licenses in the expressions itself. This you will get a list like this:
+
+        ["GPL-2.0-only"]
+
+        """
+        compats = []
+        if not licenses_to_check:
+            licenses_to_check = self.licenses(license_expr)
+
+        license_expression_parsed = self.flame.expression_license(license_expr, update_dual=False)['identified_license']
+        for lic in licenses_to_check:
+            logging.debug(f' check licenses: {lic}')
+            try:
+                ret = self.le.check_compatibility(lic,
+                                                  license_expression_parsed,
+                                                  usecase,
+                                                  provisioning,
+                                                  resources)
+                if ret['compatibility'] == 'yes':
+                    compats.append(lic)
+                    logging.debug(f' appending: {lic}')
+            except Exception as e:
+                logging.debug(f'Exception caught: {e}')
+                logging.debug(traceback.format_exc())
+
+        # decorate compat list with indices (from rankings)
+        decorated = [(self.__compat_index(lic, usecase, provisioning), lic) for lic in compats]
+
+        # sort and reverse (to get the most compatible first)
+        decorated.sort()
+        decorated.reverse()
+
+        # undecorate
+        sorted_compats = [lic for index, lic in decorated]
+
+        return sorted_compats
+
+    def __compat_index(self, lic, usecase, provisioning):
+        # returns the ranking index for a license,
+        # given usecase and provisioning
+
+        # initialize the ranking
+        self.compatibility_rankings(usecase, provisioning)
+        return self._compatibility_rankings[usecase][provisioning][lic]['index']

licomp_toolkit/toolkit.py

@@ -0,0 +1,504 @@
+# SPDX-FileCopyrightText: 2024 Henrik Sandklef
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import logging
+from license_expression import Licensing
+
+from licomp.interface import Licomp
+from licomp.interface import UseCase
+from licomp.interface import Provisioning
+from licomp.interface import LicompException
+from licomp.return_codes import ReturnCodes
+from licomp.interface import CompatibilityStatus
+
+from licomp_osadl.osadl import LicompOsadl
+from licomp_reclicense.reclicense import LicompReclicense
+from licomp_proprietary.proprietary import LicompProprietary
+from licomp_dwheeler.dwheeler import LicompDw
+from licomp_hermione.hermione import LicompHermione
+from licomp_gnuguide.gnuguide import GnuQuickGuideLicense
+from licomp_oslc_handbook.oslc_handbook import LicompOslcHandbook
+from licomp_doubleopen.doubleopen import LicompDoubleOpen
+
+from licomp_toolkit.config import disclaimer
+from licomp_toolkit.config import licomp_toolkit_version
+from licomp_toolkit.config import licomp_toolkit_file_version
+from licomp_toolkit.config import cli_name
+from licomp_toolkit.config import module_name
+
+from licomp_toolkit.expr_parser import LicenseExpressionParser
+from licomp_toolkit.expr_parser import COMPATIBILITY_TYPE
+from licomp_toolkit.expr_parser import AND
+from licomp_toolkit.expr_parser import OR
+
+from licomp_toolkit.config import my_supported_api_version
+
+class LicompToolkit(Licomp):
+    """A class implementing Licomp, but for a misc Licomp resources
+    and packaging the responses into a new reply
+    (licomp_toolkit/reply_schema.json).
+
+    LicompToolkit can check a single license agaisnt another for
+    compatibility, but not license expressions.
+    """
+
+    def __init__(self):
+        Licomp.__init__(self)
+        self._licomp_resources = {}
+        for licomp in [LicompReclicense, LicompOsadl]:
+            licomp_instance = licomp()
+            self._licomp_resources[licomp_instance.name()] = licomp_instance
+
+        self._licomp_resources_optional = {}
+        for licomp in [LicompHermione, LicompProprietary, LicompDw, GnuQuickGuideLicense, LicompOslcHandbook, LicompDoubleOpen]:
+            licomp_instance = licomp()
+            self._licomp_resources_optional[licomp_instance.name()] = licomp_instance
+
+    def supported_api_version(self):
+        return my_supported_api_version
+
+    def __add_to_list(self, store, data, name):
+        if not data:
+            return
+        if data not in store:
+            store[data] = []
+        store[data].append(name)
+
+    def __add_meta(self, compatibilities):
+        compatibilities["meta"] = {}
+        compatibilities["meta"]['disclaimer'] = disclaimer
+
+    def licomp_resources(self):
+        return self._licomp_resources | self._licomp_resources_optional
+
+    def licomp_standard_resources(self):
+        return self._licomp_resources
+
+    def licomp_optional_resources(self):
+        return self._licomp_resources_optional
+
+    def licomp_resource_long(self, resource):
+        return {
+            'name': resource.name(),
+            'version': resource.version(),
+            'usecases': [UseCase.usecase_to_string(x) for x in resource.supported_usecases()],
+            'provisionings': [Provisioning.provisioning_to_string(x) for x in resource.supported_provisionings()],
+            'licenses': resource.supported_licenses(),
+            'type': self._resource_type(resource),
+        }
+
+    def licomp_resources_long(self):
+        _resources = []
+        for resource in self.licomp_resources().values():
+            _resources.append(self.licomp_resource_long(resource))
+        return _resources
+
+    def licomp_resources_short(self):
+        _resources = []
+        for resource in self.licomp_resources().values():
+            _resources.append(f'{resource.name()}:{resource.version()}')
+        return _resources
+
+    def _resource_type(self, resource):
+        if self._resource_is_standard(resource):
+            return 'standard'
+        return 'optional'
+
+    def _resource_is_optional(self, resource):
+        return resource.name() in self._licomp_resources_optional
+
+    def _resource_is_standard(self, resource):
+        return not self._resource_is_optional(resource)
+
+    def __summarize_compatibility(self, compatibilities, outbound, inbound, usecase, provisioning, resources):
+        compatibilities["summary"] = {}
+        statuses = {}
+        compats = {}
+        compatibilities['nr_licomp'] = len(resources)
+        #        for resource_name in self._licomp_resources():
+        for compat in compatibilities["compatibilities"]:
+            logging.debug(f': {compat}')
+            logging.debug(f': {compat["resource_name"]}')
+            self.__add_to_list(statuses, compat['status'], compat)
+            self.__add_to_list(compats, compat['compatibility_status'], compat)
+        compatibilities["summary"]["resources"] = self.licomp_resources_short()
+        compatibilities["summary"]["outbound"] = outbound
+        compatibilities["summary"]["inbound"] = inbound
+        compatibilities["summary"]["usecase"] = UseCase.usecase_to_string(usecase)
+        compatibilities["summary"]["provisioning"] = Provisioning.provisioning_to_string(provisioning)
+        compatibilities["summary"]["statuses"] = statuses
+        compatibilities["summary"]["compatibility_statuses"] = compats
+
+        compat_number = len(compatibilities["summary"]["statuses"].get("success", []))
+        logging.debug(f': {compatibilities["summary"]["statuses"]}')
+        results = {}
+        results['nr_valid'] = f'{compat_number}'
+        for key, value in compatibilities["summary"]["compatibility_statuses"].items():
+            logging.debug(f': {len(value)}/{compat_number}')
+            if compat_number == 0:
+                continue
+            else:
+                if key == 'unsupported':
+                    continue
+                else:
+                    count = len(value)
+                    perc = len(value) / compat_number * 100
+            results[key] = {
+                'count': count,
+                'percent': perc,
+            }
+        compatibilities['summary']['results'] = results
+
+    # override top class
+    def outbound_inbound_compatibility(self, outbound, inbound, usecase, provisioning, resources=None):
+        logging.debug(f'{inbound} {outbound} ')
+
+        compatibilities = {}
+        compatibilities['compatibilities'] = []
+
+        if not resources:
+            resources = self.licomp_resources().keys()
+
+        for resource_name in resources:
+            resource = self.licomp_resources()[resource_name]
+            logging.debug(f'-- resource: {resource.name()}')
+
+            compat = resource.outbound_inbound_compatibility(outbound, inbound, usecase, provisioning=provisioning)
+            compatibilities['compatibilities'].append(compat)
+
+        self.__summarize_compatibility(compatibilities, outbound, inbound, usecase, provisioning, resources)
+        self.__add_meta(compatibilities)
+
+        return compatibilities
+
+    def simplify(self, lic):
+        return str(Licensing([]).parse(lic).simplify())
+
+    def supported_licenses(self):
+        licenses = set()
+        for resource in self.licomp_resources().values():
+            licenses.update(set(resource.supported_licenses()))
+        licenses = list(licenses)
+        licenses.sort()
+        return licenses
+
+    def supported_provisionings(self):
+        provisionings = set()
+        for resource in self.licomp_resources().values():
+            provisionings.update(set(resource.supported_provisionings()))
+        return list(provisionings)
+
+    def supported_usecases(self):
+        usecases = set()
+        for resource in self.licomp_resources().values():
+            usecases.update(set(resource.supported_usecases()))
+        return list(usecases)
+
+    def disclaimer(self):
+        return disclaimer
+
+    def version(self, verbose=False):
+        return licomp_toolkit_version
+
+    def versions(self, verbose=False):
+        resources = {}
+        for resource in self.licomp_resources().values():
+            resources[resource.name()] = resource.version()
+        return {
+            self.name(): self.version(),
+            'licomp-resources': resources,
+        }
+
+    def name(self):
+        return cli_name
+
+class LicenseExpressionChecker():
+    """This class can check compatibility between a single outbound
+    license (e.g GPL-2.0-only) against an inbound license expression
+    (e.g. MIT OR X11)
+    """
+
+    def __init__(self):
+        self.le_parser = LicenseExpressionParser()
+        self.licomp_toolkit = LicompToolkit()
+
+    def __compatibility_status(self, compatibility):
+        status = compatibility['summary']['results']
+        rets = []
+        for ret in status:
+            if ret == 'nr_valid':
+                continue
+            elif not ret:
+                pass
+            elif ret == CompatibilityStatus.compat_status_to_string(CompatibilityStatus.UNSUPPORTED):
+                pass
+            else:
+                rets.append(ret)
+
+        if len(rets) == 0:
+            return CompatibilityStatus.compat_status_to_string(CompatibilityStatus.UNSUPPORTED)
+
+        if len(rets) == 1:
+            return rets[0]
+
+        return CompatibilityStatus.compat_status_to_string(CompatibilityStatus.MIXED)
+
+    def check_compatibility(self,
+                            outbound,
+                            parsed_expression,
+                            usecase,
+                            provisioning,
+                            resources,
+                            detailed_report=True):
+
+        compat_object = {
+            'compatibility_check': f'outbound-{self.le_parser.parse_license_expression(outbound)["compatibility_type"]} -> inbound-{parsed_expression["compatibility_type"]}',
+            'check_class': __class__.__name__,
+        }
+
+        if parsed_expression[COMPATIBILITY_TYPE] == 'license':
+            compat_object['compatibility_check'] = 'outbound-license -> inbound-license'
+            lic = parsed_expression['license']
+            compat = self.licomp_toolkit.outbound_inbound_compatibility(outbound,
+                                                                        lic,
+                                                                        usecase,
+                                                                        provisioning,
+                                                                        resources)
+            compat_object['compatibility'] = self.__compatibility_status(compat)
+            if detailed_report:
+                compat_object['compatibility_details'] = compat
+            else:
+                compat_object['compatibility_details'] = None
+            compat_object['inbound_license'] = lic
+            compat_object['outbound_license'] = outbound
+            compat_object['compatibility_object'] = {}
+
+        else:
+            operator = parsed_expression['operator']
+            operands = parsed_expression['operands']
+            compat_object['operator'] = operator
+
+            compat_object['inbound_license'] = self.le_parser.to_string(parsed_expression)
+            compat_object['outbound_license'] = outbound
+            compat_object['compatibility_details'] = None
+            operands_object = []
+            for operand in operands:
+                operand_compat = self.check_compatibility(outbound, operand, usecase, provisioning, resources, detailed_report=detailed_report)
+                operand_object = {
+                    'compatibility_object': operand_compat,
+                    'compatibility': operand_compat['compatibility'],
+                }
+                operands_object.append(operand_object)
+
+            compat_object['compatibility'] = self.summarise_compatibilities(operator, operands_object)
+            compat_object['operands'] = operands_object
+
+        return compat_object
+
+    def __init_summary(self, operands):
+        summary = {
+            "yes": 0,
+            "no": 0,
+            "depends": 0,
+            "unknown": 0,
+            "unsupported": 0,
+            "mixed": 0,
+        }
+        for operand in operands:
+            compat = operand['compatibility']
+            summary[compat] = summary[compat] + 1
+        return summary
+
+    def __summarise_compatibilities_and(self, operands):
+        nr_operands = len(operands)
+        summary = self.__init_summary(operands)
+
+        if summary['no'] != 0:
+            return 'no'
+
+        if summary['yes'] == nr_operands:
+            return "yes"
+
+        return "no"
+
+    def __summarise_compatibilities_or(self, operands):
+        summary = self.__init_summary(operands)
+
+        if summary['yes'] != 0:
+            return 'yes'
+
+        return "no"
+
+    def summarise_compatibilities(self, operator, operands):
+        return {
+            AND: self.__summarise_compatibilities_and,
+            OR: self.__summarise_compatibilities_or,
+        }[operator](operands)
+
+
+class ExpressionExpressionChecker():
+    """
+    This class can check, for compatibility;
+    * inbound license expression (e.g. MIT OR Apache-2.0)
+    * against outbound license expression (e.g. GPL-2.0-only OR BSD-2-Clause)
+    """
+
+    def __init__(self):
+        self.le_checker = LicenseExpressionChecker()
+        self.le_parser = LicenseExpressionParser()
+        self.licomp_toolkit = LicompToolkit()
+
+    def __parsed_expression_to_name(self, parsed_expression):
+        return parsed_expression[parsed_expression[COMPATIBILITY_TYPE]]
+
+    def meta_information(self):
+        return {
+            'tool': module_name,
+            'file': 'verification',
+            'file_version': licomp_toolkit_file_version,
+        }
+
+    def check_compatibility(self, outbound, inbound, usecase, provisioning, resources=None, detailed_report=True):
+
+        # Check usecase
+        try:
+            usecase_obj = UseCase.string_to_usecase(usecase)
+        except KeyError:
+            raise LicompException(f'Usecase {usecase} not supported.', ReturnCodes.LICOMP_UNSUPPORTED_USECASE)
+
+        # Check provisioning
+        try:
+            provisioning_obj = Provisioning.string_to_provisioning(provisioning)
+        except KeyError:
+            raise LicompException(f'Provisioning {provisioning} not supported.', ReturnCodes.LICOMP_UNSUPPORTED_PROVISIONING)
+
+        licomp_resources = list(self.licomp_toolkit.licomp_standard_resources().keys())
+        if not resources:
+            resources = licomp_resources
+        else:
+            resources = resources
+
+        unavailable_resources = []
+
+        for resource in resources:
+            resource_object = self.licomp_toolkit.licomp_resources()[resource]
+            unavailable_reasons = []
+
+            # is usecase supported by resource
+            if not resource_object.usecase_supported(UseCase.string_to_usecase(usecase)):
+                unavailable_reasons.append(f'Usecase "{usecase}" not supported')
+
+            # is prov case supported by resource
+            if not resource_object.provisioning_supported(Provisioning.string_to_provisioning(provisioning)):
+                unavailable_reasons.append(f'Provisioning case "{provisioning}" not supported')
+
+            if unavailable_reasons:
+                unavailable_resources.append({
+                    "resource": resource,
+                    'reasons': ", ".join(unavailable_reasons),
+                })
+
+        unavailable_resource_keys = [resource['resource'] for resource in unavailable_resources]
+        available_resources = [resource for resource in resources if resource not in unavailable_resource_keys]
+
+        inbound_parsed = self.le_parser.parse_license_expression(inbound)
+        outbound_parsed = self.le_parser.parse_license_expression(outbound)
+        compatibility_object = self.__check_compatibility(outbound_parsed,
+                                                          inbound_parsed,
+                                                          usecase_obj,
+                                                          provisioning_obj,
+                                                          resources,
+                                                          detailed_report)
+        return {
+            'meta': self.meta_information(),
+            'inbound': str(inbound),
+            'outbound': str(outbound),
+            'usecase': usecase,
+            'resources': resources,
+            'provisioning': provisioning,
+            'compatibility': compatibility_object['compatibility'],
+            'compatibility_report': compatibility_object,
+            'unavailable_resources': unavailable_resources,
+            'available_resources': available_resources,
+        }
+
+    def __check_compatibility(self,
+                              outbound_parsed,
+                              inbound_parsed,
+                              usecase,
+                              provisioning,
+                              resources,
+                              detailed_report=True):
+
+        outbound_type = outbound_parsed[COMPATIBILITY_TYPE]
+        compat_object = {
+            'inbound_license': self.le_parser.to_string(inbound_parsed),
+            'outbound_license': self.le_parser.to_string(outbound_parsed),
+            'check_class': __class__.__name__,
+        }
+
+        if outbound_type == 'license':
+            if False:
+                compat_object['compatibility_check'] = f'outbound-license -> inbound-{inbound_parsed["compatibility_type"]} HERE?'
+                outbound_parsed_license = outbound_parsed['license']
+
+                compat = self.le_checker.check_compatibility(outbound_parsed_license,
+                                                             inbound_parsed,
+                                                             usecase,
+                                                             provisioning,
+                                                             resources,
+                                                             detailed_report)
+                compat_object['compatibility'] = compat['compatibility']
+                compat_object['compatibility_object'] = compat
+                compat_object['compatibility_details'] = None
+
+            outbound_parsed_license = outbound_parsed['license']
+            compat = self.le_checker.check_compatibility(outbound_parsed_license,
+                                                         inbound_parsed,
+                                                         usecase,
+                                                         provisioning,
+                                                         resources,
+                                                         detailed_report)
+            compat_object = compat
+
+        elif outbound_type == 'expression':
+            compat_object['compatibility_details'] = None
+            compat_object['compatibility_check'] = f'outbound-expression -> inbound-{inbound_parsed["compatibility_type"]}'
+            operator = outbound_parsed['operator']
+            operands = outbound_parsed['operands']
+
+            compat_object['operator'] = operator
+
+            operands_object = []
+            for operand in operands:
+                # Check if:
+                #    operand from outbound license
+                #    is compatible with
+                #    inbound license
+                operand_compat = self.__check_compatibility(operand,
+                                                            inbound_parsed,
+                                                            usecase,
+                                                            provisioning,
+                                                            resources,
+                                                            detailed_report)
+                operand_object = {
+                    'compatibility_object': operand_compat,
+                    'compatibility': operand_compat['compatibility'],
+                }
+                operands_object.append(operand_object)
+
+            compat_object['compatibility'] = self.le_checker.summarise_compatibilities(operator, operands_object)
+            compat_object['operands'] = operands_object
+
+        return compat_object
+
+    def simplify(self, compat):
+        return {
+            'outbound': compat['outbound'],
+            'inbound': compat['inbound'],
+            'usecase': compat['usecase'],
+            'provisioning': compat['provisioning'],
+            'compatibility': compat['compatibility'],
+            'resources': compat['available_resources'],
+        }