Allow choice of which resources to use

devel/licomp-toolkit

@@ -16,4 +16,4 @@ then
     ARGS="verify -il MIT -ol \"MIT OR X11\""
 fi     
 
-PYTHONPATH=${EXTRA_PYTHONPATH}:${PYTHONPATH} ${SCRIPT_DIR}/licomp_toolkit/__main__.py $* $ARGS
+echo PYTHONPATH=${EXTRA_PYTHONPATH}:${PYTHONPATH} ${SCRIPT_DIR}/licomp_toolkit/__main__.py $* $ARGS | bash

licomp_toolkit/__main__.py

@@ -43,12 +43,35 @@ def validate(self, args):
     def verify(self, args):
         formatter = LicompToolkitFormatter.formatter(self.args.output_format)
         try:
+            if args.no_verbose:
+                detailed_report = False
+            else:
+                detailed_report = True
+
+            resources = args.resources
+            new_resources = []
+            unsupported = []
+            for resource in resources:
+                if 'licomp' not in resource:
+                    resource = f'licomp_{resource}'
+                else:
+                    resource = resource.replace('-', '_')
+
+                if not self.resource_avilable(resource):
+                    unsupported.append(resource)
+                else:
+                    new_resources.append(resource)
+            if unsupported:
+                return f'Resource(s) {", ".join(unsupported)} is/are not supported', ReturnCodes.LICOMP_UNSUPPORTED_RESOURCE.value, True
+
+            resources = new_resources
             expr_checker = ExpressionExpressionChecker()
             compatibilities = expr_checker.check_compatibility(self.__normalize_license(args.out_license),
                                                                self.__normalize_license(args.in_license),
                                                                args.usecase,
                                                                args.provisioning,
-                                                               detailed_report=True)
+                                                               resources=resources,
+                                                               detailed_report=detailed_report)
 
             ret_code = compatibility_status_to_returncode(compatibilities['compatibility'])
             return formatter.format_compatibilities(compatibilities), ret_code, False
@@ -106,6 +129,9 @@ 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 resource_avilable(self, resource):
+        return resource in self.licomp_toolkit.licomp_resources().keys()
+
 def _working_return_code(return_code):
     return return_code < ReturnCodes.LICOMP_LAST_SUCCESSFUL_CODE.value
 
@@ -118,8 +144,20 @@ def main():
                                      UseCase.LIBRARY,
                                      Provisioning.BIN_DIST)
 
+    parser = lct_parser.parser
     subparsers = lct_parser.sub_parsers()
 
+    parser.add_argument('-r', '--resources',
+                        type=str,
+                        action='append',
+                        help='use only specified licomp resource',
+                        default=[])
+
+    parser.add_argument('-nv', '--no-verbose',
+                        action='store_true',
+                        help='keep compatibility report as short as possible',
+                        default=[])
+
     # Command: list supported
     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)

licomp_toolkit/data/reply_schema.json

@@ -31,12 +31,42 @@
       "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" ],
+  "required" : [ "compatibility_report", "compatibility", "outbound", "inbound" , "usecase", "resources", "unavailable_resources", "available_resources" ],
   "additionalProperties" : false,
   "$defs": {
     "compatibility_object": {

licomp_toolkit/format.py

@@ -47,16 +47,93 @@ def format_licomp_resources(self, 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(self, compat):
+        PAREN_OPEN = '('
+        PAREN_START = ')'
+        return f'{PAREN_OPEN}{compat}{PAREN_START}'
+
+    def format_compatibilities_object(self, compat_object, indent=''):
+        compatibility_check = compat_object["compatibility_check"]
+        output = []
+
+        if compatibility_check == "outbound-license -> inbound-license":
+            if not compat_object["compatibility_object"]:
+                pass
+            else:
+                compat_object = compat_object["compatibility_object"]
+            details = compat_object["compatibility_details"]
+            summary = details["summary"]
+
+            output.append(f'{indent}{compat_object["outbound_license"]} -> {compat_object["inbound_license"]} {self._format_compat(compat_object["compatibility"])}')
+            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["compatibility_object"]["operator"]
+            output.append(f'{indent}{operator} {self._format_compat(compat_object["compatibility"])}')
+            for operand in compat_object["compatibility_object"]["operands"]:
+                res = self.format_compatibilities_object(operand['compatibility_object'], indent=f'{indent}  ')
+                output.append(res)
+
+        if compatibility_check == "outbound-expression -> inbound-license":
+            operator = compat_object["operator"]
+            output.append(f'{indent}{operator} {self._format_compat(compat_object["compatibility"])}')
+            for operand in compat_object["operands"]:
+                res = self.format_compatibilities_object(operand['compatibility_object'], indent=f'{indent}  ')
+                output.append(res)
+        if compatibility_check == "outbound-expression -> inbound-expression":
+            operator = compat_object["operator"]
+            compat = compat_object["compatibility"]
+            output.append(f'{indent}{operator} {self._format_compat(compat)}')
+            for operand in compat_object['operands']:
+                res = self.format_compatibilities_object(operand['compatibility_object'], indent=f'{indent}  ')
+                output.append(f'{res}')
+
+        return "\n".join(output)
+
     def format_compatibilities(self, compat):
-        summary = compat['summary']
         output = []
-        nr_valid = summary['results']['nr_valid']
-        output.append(f'{nr_valid} succesfull response(s)')
-        if int(nr_valid) > 0:
-            output.append('Results:')
-            statuses = summary['compatibility_statuses']
-            for status in statuses.keys():
-                output.append(f'   {status}: {", ".join(statuses[status])}')
+        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"]}')
+        output.append('report:')
+        output.append(self.format_compatibilities_object(compat["compatibility_report"], '  '))
+
         return "\n".join(output)
 
     def format_licomp_versions(self, licomp_versions):