licomp-toolkit 0.6.3__py3-none-any.whl

licomp_toolkit/display_compatibility.py

@@ -0,0 +1,21 @@
+# SPDX-FileCopyrightText: 2024 Henrik Sandklef
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+class DisplayCompatibility:
+
+    def __init__(self, licomp_toolkit):
+        self.licomp_toolkit = licomp_toolkit
+
+    def display_compatibility(self, licenses, usecase, provisioning, resources):
+        compats = {}
+        for outbound in licenses:
+            compats[outbound] = {}
+            for inbound in licenses:
+                ret = self.licomp_toolkit.outbound_inbound_compatibility(outbound,
+                                                                         inbound,
+                                                                         usecase,
+                                                                         provisioning,
+                                                                         resources)
+                compats[outbound][inbound] = ret
+        return compats

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

@@ -0,0 +1,139 @@
+# SPDX-FileCopyrightText: 2025 Henrik Sandklef
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import logging
+
+from license_expression import Licensing
+from licomp.interface import LicompException
+from licomp.return_codes import ReturnCodes
+
+AND = "AND"
+OR = "OR"
+
+COMPATIBILITY_TYPE = 'compatibility_type'
+
+class LicenseExpressionParser():
+
+    def __init__(self):
+        self.licensing = Licensing([])
+
+        self.CLOSE_PARENTHESIS = ")"
+        self.LICENSE_SYMBOL = "LicenseSymbol"
+        self.LICENSE_WITH_SYMBOL = "LicenseWithExceptionSymbol"
+
+    def parse_license_expression(self, expression):
+        if not expression:
+            raise LicompException("No license provided: " + str(expression), ReturnCodes.LICOMP_PARSE_ERROR)
+        p = self.__parse_expression(self.licensing.parse(expression).pretty().replace('\n', ' '))
+        return p
+
+    def __is_license_with_exception(self, expression):
+        return expression.strip().startswith(self.LICENSE_WITH_SYMBOL)
+
+    def __is_license(self, expression, with_exception=False):
+        if with_exception:
+            return expression.strip().startswith(self.LICENSE_SYMBOL) or expression.strip().startswith(self.LICENSE_WITH_SYMBOL)
+        return expression.strip().startswith(self.LICENSE_SYMBOL)
+
+    def __is_operator(self, expression):
+        return expression.startswith(AND) or expression.startswith(OR)
+
+    def __get_operator(self, expression):
+        if expression.startswith(AND):
+            return AND
+        if expression.startswith(OR):
+            return OR
+        raise Exception("BAD EXPRESSION----")
+
+    def __get_operands_string(self, expression):
+        # length of the operator and parenthesis
+        op = self.__get_operator(expression)
+        op_size = len(op) + 1
+
+        # nr characters until closing (operator) parenthesis
+        left_parens = 1
+        operand_size = 1
+        for c in expression[op_size:]:
+            operand_size += 1
+            if c == '(':
+                left_parens += 1
+            elif c == ')':
+                left_parens -= 1
+
+            if left_parens == 0:
+                break
+
+        rest = expression[op_size:operand_size + 1]
+        remains = expression[operand_size + 4:]
+        return rest, remains
+
+    def is_close(self, expression):
+        return expression.startswith(self.CLOSE_PARENTHESIS)
+
+    def __cleanup_license(self, operand):
+        stripped_operand = operand.strip()
+
+        if self.__is_license_with_exception(operand):
+            trimmed_operand = stripped_operand.replace(f"{self.LICENSE_WITH_SYMBOL}('", '', 1)
+        else:
+            trimmed_operand = stripped_operand.replace(f"{self.LICENSE_SYMBOL}('", '', 1)
+        closing_paren_index = trimmed_operand.find(")")
+        op = trimmed_operand[:closing_paren_index - 1]
+        remains = trimmed_operand[closing_paren_index + 1:].strip()
+        if remains.startswith(","):
+            remains = remains[1:]
+        return op, remains.strip()
+
+    def __parse_expression(self, expression):
+        logging.debug(f'__parse_expression: {expression}')
+
+        if self.__is_operator(expression):
+            operator = self.__get_operator(expression)
+            operands = []
+            ops, remains = self.__get_operands_string(expression)
+            while ops != "":
+                if self.__is_license(ops.strip(), with_exception=True):
+                    operand, rem = self.__cleanup_license(ops)
+                    operands.append({
+                        COMPATIBILITY_TYPE: "license",
+                        'license': operand,
+                    })
+                    ops = rem
+
+                elif self.__is_operator(ops.strip()):
+                    operand = self.__parse_expression(ops.strip())
+                    _ops, _remains = self.__get_operands_string(ops.strip())
+                    operands.append(operand)
+                    ops = _remains
+
+                else:
+                    raise LicompException(f'Failed parsing expression "{ops}". Complete expression "{expression}"', ReturnCodes.LICOMP_PARSE_ERROR)
+            return {
+                COMPATIBILITY_TYPE: 'expression',
+                "operator": operator,
+                "operands": operands,
+            }
+
+        elif self.__is_license(expression, with_exception=True):
+            cleaned_up, rem = self.__cleanup_license(expression.strip())
+            return {
+                COMPATIBILITY_TYPE: "license",
+                'license': cleaned_up,
+            }
+
+        elif self.__is_close(expression):
+            return ""
+
+        raise Exception("Bottom reached in __parse_expression (expr_parser.py)")
+
+    def to_string(self, parsed_license):
+        license_type = parsed_license['compatibility_type']
+        if license_type == 'license':
+            return parsed_license['license']
+
+        operator = parsed_license['operator']
+        license_expression = []
+        for operand in parsed_license['operands']:
+            license_expression.append(f' ( {self.to_string(operand)} ) ')
+        return str(self.licensing.parse(operator.join(license_expression)))

licomp_toolkit/format.py

@@ -0,0 +1,362 @@
+# SPDX-FileCopyrightText: 2025 Henrik Sandklef
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import json
+import yaml
+
+class LicompToolkitFormatter():
+
+    @staticmethod
+    def formatter(fmt):
+        if fmt.lower() == 'json':
+            return JsonLicompToolkitFormatter()
+        if fmt.lower() == 'text':
+            return TextLicompToolkitFormatter()
+        if fmt.lower() == 'yaml' or fmt.lower() == 'yml':
+            return YamlLicompToolkitFormatter()
+        if fmt.lower() == 'dot':
+            return DotLicompToolkitFormatter()
+
+    def format_compatibilities(self, compat, verbose=False):
+        raise Exception(f'{self.__class__.__name__} cannot format compatibilities.')
+
+    def _pre_format_display_compatibilities(self, compats):
+        licenses = list(compats.keys())
+        finished = {}
+        for outbound in licenses:
+            finished[outbound] = {}
+            for inbound in licenses:
+                finished[outbound][inbound] = False
+
+        for outbound in licenses:
+            for inbound in licenses:
+                if finished[outbound][inbound] and finished[inbound][outbound]:
+                    continue
+                if outbound == inbound:
+                    finished[outbound][inbound] = ['yes']
+                    finished[inbound][outbound] = ['yes']
+                else:
+                    outbound_compat = compats[outbound][inbound]['summary']['compatibility_statuses']
+                    inbound_compat = compats[inbound][outbound]['summary']['compatibility_statuses']
+                    finished[outbound][inbound] = list(outbound_compat.keys())
+                    finished[inbound][outbound] = list(inbound_compat.keys())
+
+        return finished
+
+    def format_licomp_resources(self, licomp_resources):
+        raise Exception(f'{self.__class__.__name__} cannot format licomp resources.')
+
+    def format_licomp_licenses(self, licomp_licenses):
+        raise Exception(f'{self.__class__.__name__} cannot format licomp licenses.')
+
+    def format_licomp_versions(self, licomp_versions):
+        raise Exception(f'{self.__class__.__name__} cannot format licomp versions.')
+
+class JsonLicompToolkitFormatter(LicompToolkitFormatter):
+
+    def format_compatibilities(self, compat, verbose=False):
+        return json.dumps(compat, indent=4)
+
+    def format_licomp_resources(self, licomp_resources):
+        return json.dumps(licomp_resources, indent=4)
+
+    def format_licomp_licenses(self, licomp_licenses):
+        return json.dumps(licomp_licenses, indent=4)
+
+    def format_licomp_versions(self, licomp_versions):
+        return json.dumps(licomp_versions, indent=4)
+
+    def format_display_compatibilities(self, compats, settings={}): # noqa: B006
+        # settings
+        #  discard_unsupported: True - will remove unsupported licenses from the output
+        display_compats = self._pre_format_display_compatibilities(compats)
+        return json.dumps(display_compats, indent=4)
+
+    def format_policy_report(self, report, verbose=False):
+        return json.dumps(report, indent=4)
+
+class YamlLicompToolkitFormatter(LicompToolkitFormatter):
+
+    def format_compatibilities(self, compat, verbose=False):
+        return yaml.safe_dump(compat, indent=4)
+
+    def format_policy_report(self, report, verbose=False):
+        return yaml.safe_dump(report, indent=4)
+
+    def format_licomp_resources(self, licomp_resources):
+        return yaml.safe_dump(licomp_resources, indent=4)
+
+    def format_licomp_licenses(self, licomp_licenses):
+        return yaml.safe_dump(licomp_licenses, indent=4)
+
+    def format_licomp_versions(self, licomp_versions):
+        return yaml.safe_dump(licomp_versions, indent=4)
+
+    def format_display_compatibilities(self, compats, settings={}): # noqa: B006
+        display_compats = self._pre_format_display_compatibilities(compats)
+        return yaml.safe_dump(display_compats, indent=4)
+
+class TextLicompToolkitFormatter(LicompToolkitFormatter):
+
+    def _format_licomp_resource(self, licomp_resource):
+        name = licomp_resource['name']
+        version = licomp_resource['version']
+        usecases = ','.join(licomp_resource['usecases'])
+        provisionings = ','.join(licomp_resource['provisionings'])
+        resource_type = licomp_resource['type']
+        return f'{name}:{version}:{usecases}:{provisionings}:{resource_type}'
+
+    def format_licomp_resources(self, licomp_resources):
+        return '\n'.join([self._format_licomp_resource(x) for x in licomp_resources])
+
+    def format_licomp_licenses(self, licomp_licenses):
+        return '\n'.join(licomp_licenses)
+
+    def __get_responses(self, results, indent=''):
+        output = []
+        for res in ['yes', 'no', 'schneben']:
+            result = results.get(res)
+            if not result:
+                count = 0
+            else:
+                count = result['count']
+            output.append(f'{indent}{res}: {count}')
+
+        return output
+
+    def __compatibility_statuses(self, statuses, indent=''):
+        output = []
+        for status, values in statuses.items():
+            resources = []
+            for value_object in values:
+                resources.append(value_object['resource_name'])
+            output.append(f'{indent}{status}: {", ".join(resources)}')
+
+        return output
+
+    def __statuses(self, statuses, indent=''):
+        output = []
+        for status, values in statuses.items():
+            resources = []
+            for value_object in values:
+                resources.append(value_object['resource_name'])
+            output.append(f'{indent}{status}: {", ".join(resources)}')
+
+        return output
+
+    def _format_compat_value(self, compat):
+        return {'yes': 'compatible'}.get(compat, 'incompatible')
+
+    def _format_compat_pref(self, compat, pref_lic=None):
+        PAREN_OPEN = '('
+        PAREN_CLOSE = ')'
+        compat_string = self._format_compat_value(compat)
+        if pref_lic:
+            return f'{PAREN_OPEN}{compat_string}, {pref_lic}{PAREN_CLOSE}'
+        else:
+            return f'{PAREN_OPEN}{compat_string}{PAREN_CLOSE}'
+
+    def format_compatibilities_general(self, compat_object, indent='', policy_report=False, preferred_license=None):
+        compatibility_check = compat_object["compatibility_check"]
+        output = []
+
+        if compatibility_check == "outbound-license -> inbound-license":
+            compat_object = compat_object
+            details = compat_object["compatibility_details"]
+            summary = details["summary"]
+            preferred_info = 'no'
+            if policy_report and preferred_license == compat_object["policy_check"]["inbound"]["preferences"]["license"]:
+                preferred_info = 'yes'
+            output.append(f'{indent}{compat_object["outbound_license"]} -> {compat_object["inbound_license"]}')
+            if policy_report:
+                output.append(f'{indent}  preferred:               {preferred_info}')
+            output.append(f'{indent}  compatibility:           {compat_object["compatibility"]}')
+            output.append(f'{indent}  compatibility details:   ')
+            output += self.__compatibility_statuses(summary['compatibility_statuses'], f'{indent}    ')
+
+        if compatibility_check == "outbound-license -> inbound-expression":
+            operator = compat_object["operator"]
+            inner_output = []
+            preferred_info = 'no'
+            if policy_report and preferred_license == compat_object['policy_check']['inbound']['preferences']['license']:
+                preferred_info = 'yes'
+            for operand in compat_object["operands"]:
+                res = self.format_compatibilities_general(operand['compatibility_object'], indent=f'{indent}    ', policy_report=policy_report, preferred_license=preferred_license)
+                inner_output.append(res)
+            if policy_report:
+                output.append(f'{indent}{operator} {self._format_compat_pref(compat_object["compatibility"], preferred_license)}')
+                output.append(f'{indent}  check:           {compatibility_check}')
+                output.append(f'{indent}  outbound:        {compat_object["outbound_license"]}')
+                output.append(f'{indent}  inbound:         {compat_object["inbound_license"]}')
+                output.append(f'{indent}  comaptibility:   {compat_object["compatibility"]}')
+                output.append(f'{indent}  preferred:       {preferred_info}')
+                output.append(f'{indent}  details:')
+                output += inner_output
+
+        if compatibility_check == "outbound-expression -> inbound-license":
+            operator = compat_object["operator"]
+            output.append(f'{indent}{operator} {self._format_compat_pref(compat_object["compatibility"])}')
+            for operand in compat_object["operands"]:
+                res = self.format_compatibilities_general(operand['compatibility_object'], indent=f'{indent}  ', policy_report=policy_report, preferred_license=preferred_license)
+                output.append(res)
+        if compatibility_check == "outbound-expression -> inbound-expression":
+            operator = compat_object["operator"]
+            compat = compat_object["compatibility"]
+            preferred_info = 'no'
+            if policy_report and preferred_license == compat_object['policy_check']['inbound']['preferences']['license']:
+                preferred_info = 'yes'
+            output.append(f'{indent}{operator} {self._format_compat_pref(compat)}')
+            output.append(f'{indent}  check: {compatibility_check}')
+            output.append(f'{indent}  outbound:        {compat_object["outbound_license"]}')
+            output.append(f'{indent}  inbound:         {compat_object["inbound_license"]}')
+            output.append(f'{indent}  comaptibility:   {compat_object["compatibility"]}')
+            output.append(f'{indent}  preferred:       {preferred_info}')
+            output.append(f'{indent}  details:')
+            for operand in compat_object['operands']:
+                res = self.format_compatibilities_general(operand['compatibility_object'], indent=f'{indent}  ', policy_report=policy_report, preferred_license=preferred_license)
+                output.append(f'{res}')
+
+        return "\n".join(output)
+
+    def format_compatibilities_object(self, compat_object):
+        return self.format_compatibilities_general(compat_object, indent='')
+
+    def format_policy_report(self, report, verbose=False):
+        output = []
+        preferred_inbound = report['compatibility_report']['policy_check']['inbound']['preferences']['license']
+        preferred_outbound = report['compatibility_report']['policy_check']['outbound']['preferences']['license']
+
+        policy_info = report['meta']['policy_type']
+        if policy_info == 'policy_file':
+            policy_info = f'{policy_info} {report["meta"]["policy_file"]}'
+
+        output.append(f'outbound:           {report["outbound"]}')
+        output.append(f'inbound:            {report["inbound"]}')
+        res = ', '.join(report['resources'])
+        output.append(f'resources:          {res}')
+        output.append(f'provisioning:       {report["provisioning"]}')
+        output.append(f'usecase:            {report["usecase"]}')
+        output.append(f'policy:             {policy_info}')
+        output.append(f'compatibility:      {report["compatibility"]}')
+        output.append(f'preferred inbound:  {preferred_inbound}')
+        output.append(f'preferred outbound: {preferred_outbound}')
+
+        if verbose:
+            output.append('report:')
+            output.append(self.format_compatibilities_general(report["compatibility_report"], indent='  ', policy_report=True, preferred_license=preferred_inbound))
+        return "\n".join(output)
+
+    def format_compatibilities(self, compat, verbose=False):
+        output = []
+        output.append(f'outbound:      {compat["outbound"]}')
+        output.append(f'inbound:       {compat["inbound"]}')
+        output.append(f'resources:     {", ".join(compat["resources"])}')
+        output.append(f'provisioning:  {compat["provisioning"]}')
+        output.append(f'usecase:       {compat["usecase"]}')
+        output.append(f'compatibility: {compat["compatibility"]}')
+        if verbose:
+            output.append('report:')
+            output.append(self.format_compatibilities_general(compat["compatibility_report"], '  ', policy_report=False))
+
+        return "\n".join(output)
+
+    def format_licomp_versions(self, licomp_versions):
+        lt = 'licomp-toolkit'
+        res = [f'{lt}: {licomp_versions[lt]}']
+        for k, v in licomp_versions['licomp-resources'].items():
+            res.append(f'{k}: {v}')
+        return '\n'.join(res)
+
+    def format_display_compatibilities(self, compats):
+        display_compats = self._pre_format_display_compatibilities(compats)
+        licenses = list(display_compats.keys())
+
+        lines = []
+        for outbound in licenses:
+            for inbound in licenses:
+                lines.append(f'{outbound:30s} {"---->":10s} {inbound:30s}: {", ".join(display_compats[outbound][inbound])}')
+        return '\n'.join(lines)
+
+class DotLicompToolkitFormatter(LicompToolkitFormatter):
+
+    def _compat_line_color(self, compats):
+        _line_map = {
+            'unknown': 'style="dotted"',
+            'depends': 'style="dotted"',
+            'unsupported': 'style="dotted"',
+            'mixed': 'style="dotted"',
+        }
+        _color_map = {
+            'yes': 'darkgreen',
+            'no': 'darkred',
+        }
+        same = True
+        value = None
+        for compat in compats:
+            if compat == 'unsupported':
+                continue
+            if not value:
+                value = compat
+            else:
+                if compat != value:
+                    same = False
+
+        if same:
+            line = _line_map.get(value, '')
+            color = _color_map.get(value, 'yellow')
+        else:
+            line = _line_map['mixed']
+            color = 'darkblue'
+
+        return line, color
+
+    def _license_license_compat(self, outbound, inbound, outbound_compat, inbound_compat):
+        out_line, out_color = self._compat_line_color(outbound_compat)
+        in_line, in_color = self._compat_line_color(inbound_compat)
+        BR_START = '['
+        BR_END = ']'
+        if out_line == in_line and out_color == in_color:
+            return (f'    "{outbound}" -> "{inbound}" {BR_START}dir="both" color="{out_color}" {out_line}{BR_END}')
+        else:
+            return '\n'.join([f'    "{outbound}" -> "{inbound}" {BR_START}color="{out_color}" {out_line}{BR_END}',
+                              f'    "{inbound}" -> "{outbound}" {BR_START}color="{in_color}" {in_line}{BR_END}'])
+
+    def format_display_compatibilities(self, compats, settings={}): # noqa: B006
+        display_compats = self._pre_format_display_compatibilities(compats)
+        licenses = list(display_compats.keys())
+
+        discard_unsupported = settings.get('discard_unsupported')
+
+        lines = []
+        finished = {}
+        usecase = compats[licenses[0]][licenses[0]]['compatibilities'][0]['usecase']
+        lines.append('digraph depends {')
+        lines.append(f'    graph [label="License Compatibility Graph ({usecase})" labelloc=t]')
+        lines.append('    node [shape=plaintext]')
+        for outbound in licenses:
+            finished[outbound] = {}
+            for inbound in licenses:
+                if inbound not in finished:
+                    finished[inbound] = {}
+                if inbound == outbound:
+                    continue
+
+                if display_compats[outbound][inbound] == []:
+                    if discard_unsupported:
+                        continue
+                if display_compats[inbound][outbound] == []:
+                    if discard_unsupported:
+                        continue
+
+                if finished[outbound].get(inbound, False):
+                    continue
+                elif finished[inbound].get(outbound, False):
+                    continue
+
+                lines.append(self._license_license_compat(outbound, inbound, display_compats[outbound][inbound], display_compats[inbound][outbound]))
+                finished[outbound][inbound] = True
+                finished[inbound][outbound] = True
+
+        lines.append('}')
+        return '\n'.join(lines)