PATCH -- Workaround for multiple files (inspired by, yet, Supercedes PR #346) (- WIP #71 & #242 -)

🎉 A big, heart-felt thank you to @stefan6419846 for their work on stefan6419846/pip-licenses-cli#32 and for also reviewing #346 (upon which this workaround is closely based)

Implements some upcoming flags (plural) and contributes to supporting for multiple licenses in a single package for JSON and plain-vertical formats (but not others, e.g., HTML, etc.)

**IMPORTANT**
This workaround for GHI-71 (and related GHI-242) is ported from the Alpha-v6.0.0 branch and includes portions of PR #346 that was inspired by stefan6419846/pip-licenses-cli#32 (and thus SHOULD NOT be included as is in a release)

See also: stefan6419846/pip-licenses-cli#32

Author: reactive-firewall

pip-licenses/__init__.py

@@ -191,14 +191,64 @@ def deduplicate_and_normalize(
 )
 
 
+def _handle_multiple_value_field(
+    key: str, value: Iterator[str]
+) -> str | list[str]:
+    """Normalize a metadata field that may contain one or many values.
+
+    This helper converts an iterator of field values into the most convenient
+    representation based on the field name:
+
+    - If the field name ends with ``"s"`` (case-insensitive), the values are
+      treated as plural and returned as a list.
+    - Otherwise, the first value is returned as a single string.
+    - If a plural field has no values, ``["UNKNOWN"]`` is returned.
+    - If a singular field has no values, ``LICENSE_UNKNOWN`` is returned.
+
+    Args:
+        key: The field name used to decide whether the field should be treated
+            as singular or plural.
+        value: An iterator of string values for the field.
+
+    Returns:
+        Either:
+        - a list of strings for plural fields, or
+        - a single string for singular fields.
+
+    Examples:
+        A plural field returns all values as a list:
+
+        >>> _handle_multiple_value_field("authors", iter(["Alice", "Bob"]))
+        ['Alice', 'Bob']
+
+        A singular field returns the first value:
+
+        >>> _handle_multiple_value_field("license", iter(["MIT", "BSD"]))
+        'MIT'
+
+        An empty plural field falls back to ``["UNKNOWN"]``:
+
+        >>> _handle_multiple_value_field("authors", iter([]))
+        ['UNKNOWN']
+
+        An empty singular field falls back to ``LICENSE_UNKNOWN``:
+
+        >>> _handle_multiple_value_field("license", iter([]))
+        'UNKNOWN'
+    """
+    if key.lower().endswith("s"):
+        return list(value) or ["UNKNOWN"]
+    return cast(str, next(value, LICENSE_UNKNOWN))
+
+
 def create_licenses_table(
     args: CustomNamespace,
     output_fields: set[str] | Sequence[str] = DEFAULT_OUTPUT_FIELDS,
 ) -> PrettyTable:
     table = factory_styled_table_with_args(args, output_fields)
 
     for pkg in get_packages(args):
-        row = []
+        row: list[str | list[str]] = []
         for field in output_fields:
             if field == "License":
                 license_set = select_license_by_source(
@@ -207,17 +257,52 @@ def create_licenses_table(
                     cast(str, pkg["license"]),
                     cast(str, pkg["license_expression"]),
                 )
-                license_str = "; ".join(sorted(license_set))
+                _sorted_license_set = (
+                    sorted(license_set) if license_set else []
+                )
+                _normalized_license_set = {
+                    normal_item
+                    for normal_item in _sorted_license_set
+                    if normal_item is not None
+                }
+                license_str = "; ".join(_normalized_license_set)
                 row.append(license_str)
             elif field == "License-Classifier":
                 row.append(
                     "; ".join(sorted(pkg["license_classifier"]))
                     or LICENSE_UNKNOWN
                 )
-            elif field.lower() in pkg:
+            elif field == "License-Expression":
+                row.append(
+                    cast(str, pkg["license_expression"]) or LICENSE_UNKNOWN
+                )
+            elif field == "License-Metadata":
+                row.append(cast(str, pkg["license"]) or LICENSE_UNKNOWN)
+            elif (field.lower() in pkg) or (hasattr(pkg, field.lower())):
                 row.append(cast(str, pkg[field.lower()]))
             else:
-                row.append(cast(str, pkg[FIELDS_TO_METADATA_KEYS[field]]))
+                if (field in FIELDS_TO_METADATA_KEYS) and (
+                    FIELDS_TO_METADATA_KEYS[field] in pkg
+                ):
+                    value = pkg[FIELDS_TO_METADATA_KEYS[field]]
+                    if value:
+                        if field in _MULTI_VALUE_KEYS:
+                            row.append(
+                                cast(
+                                    list[str],
+                                    _handle_multiple_value_field(
+                                        key=field,
+                                        value=cast(Iterator[str], [*value]),
+                                    ),
+                                )
+                            )
+                        else:
+                            row.append(cast(str, value))
+                    else:  # invalid value (e.g. None)
+                        row.append(LICENSE_UNKNOWN)
+                else:  # Unknown value (e.g. custom/future fields)
+                    row.append(LICENSE_UNKNOWN)
+
         table.add_row(row)
 
     return table

pip-licenses/cli/__init__.py

@@ -163,12 +163,23 @@ def parse_args(  # type: ignore[override]
         return args_
 
     def _verify_args(self, args: CustomNamespace) -> None:
-        if args.with_license_file is False and (
-            args.no_license_path is True or args.with_notice_file is True
+        if (
+            args.with_license_file is False
+            and args.with_license_files is False
+        ) and (
+            args.no_license_path is True
+            or (
+                (
+                    args.with_notice_file is True
+                    or args.with_notice_files is True
+                )
+                or args.with_other_files is True
+            )
         ):
             self.error(
-                "'--no-license-path' and '--with-notice-file' require "
-                "the '--with-license-file' option to be set"
+                "'--no-license-path' and '--with-notice-file[s]' "
+                "as well as '--with-other-files' require "
+                "the '--with-license-file[s]' option to be set"
             )
         if args.filter_strings is False and args.filter_code_page != "latin1":
             self.error(
@@ -238,6 +249,7 @@ def create_parser(
     config_from_file = load_config_from_file(pyproject_path)
 
     common_options = parser.add_argument_group("Common options")
+    license_file_options = parser.add_argument_group("License file options")
     format_options = parser.add_argument_group("Format options")
     verify_options = parser.add_argument_group("Verify options")
 
@@ -379,7 +391,8 @@ def create_parser(
         default=config_from_file.get("no-version", False),
         help="dump without package version",
     )
-    format_options.add_argument(
+
+    license_file_options.add_argument(
         "-l",
         "--with-license-file",
         action="store_true",
@@ -389,19 +402,46 @@ def create_parser(
         "For structured formats (CSV, Markdown, reST), "
         "see README for workflow examples.",
     )
-    format_options.add_argument(
+    license_file_options.add_argument(
+        "--with-license-files",
+        action="store_true",
+        default=config_from_file.get("with-license-files", False),
+        help="dump with location of each license file and contents, most useful with JSON output",
+    )
+    license_file_options.add_argument(
         "--no-license-path",
         action="store_true",
         default=config_from_file.get("no-license-path", False),
         help="I|when specified together with option -l, "
         "suppress location of license file output",
     )
-    format_options.add_argument(
+    license_file_options.add_argument(
+        "--no-file-paths",
+        action="store_true",
+        default=config_from_file.get("no-file-paths", False),
+        help="I|Suppress location of file path outputs",
+    )
+    license_file_options.add_argument(
         "--with-notice-file",
         action="store_true",
         default=config_from_file.get("with-notice-file", False),
         help="I|when specified together with option -l, "
-        "dump with location of license file and contents",
+        "dump with location of up to one notice file and contents",
+    )
+    license_file_options.add_argument(
+        "--with-notice-files",
+        action="store_true",
+        default=config_from_file.get("with-notice-files", False),
+        help="I|when specified together with option -l, "
+        "dump with location of all notice files and contents",
+    )
+    license_file_options.add_argument(
+        "--with-other-files",
+        action="store_true",
+        default=config_from_file.get("with-other-files", False),
+        help="I|when specified together with option -l"
+        " or --with-license-files, dump with location"
+        " of other licensing-related files and contents",
     )
     format_options.add_argument(
         "--filter-strings",

pip-licenses/cli/config.py

@@ -56,8 +56,11 @@ class CustomNamespace(argparse.Namespace):
     with_urls: bool
     with_description: bool
     with_license_file: bool
+    with_license_files: bool  # added in v6.0
     no_license_path: bool
     with_notice_file: bool
+    with_notice_files: bool  # added in v6.0
+    with_other_files: bool  # added in v6.0
     filter_strings: bool
     filter_code_page: str
     partial_match: bool