Add Chromium-only Blender WebEngine parity work
This commit is contained in:
mes123456
634
blender-5.2.0/tools/utils_maintenance/make_license.py
Normal file
634
blender-5.2.0/tools/utils_maintenance/make_license.py
Normal file
@@ -0,0 +1,634 @@
|
||||
# SPDX-FileCopyrightText: 2024 Blender Authors
|
||||
#
|
||||
# SPDX-License-Identifier: GPL-2.0-or-later
|
||||
# pylint: disable=missing-function-docstring, missing-module-docstring, missing-class-docstring
|
||||
|
||||
__all__ = (
|
||||
"main",
|
||||
)
|
||||
|
||||
import datetime
|
||||
import itertools
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
|
||||
from pathlib import Path
|
||||
|
||||
from typing import (
|
||||
NamedTuple,
|
||||
)
|
||||
from collections.abc import (
|
||||
Iterator,
|
||||
)
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
# Path Constants
|
||||
|
||||
ROOT_DIR = Path(__file__).parent.parent.parent
|
||||
|
||||
DIRPATH_LICENSES: Path = ROOT_DIR / "release/license/"
|
||||
DIRPATH_EXTERN_LIBRARIES: Path = ROOT_DIR / "extern"
|
||||
|
||||
FILEPATH_VERSIONS_CMAKE: Path = ROOT_DIR / "build_files/build_environment/cmake/versions.cmake"
|
||||
FILEPATH_LICENSES_INDEX: Path = DIRPATH_LICENSES / "licenses.json" # List of licenses and definitions.
|
||||
FILEPATH_LICENSE_GENERATED: Path = DIRPATH_LICENSES / "license.md" # Generated licenses file.
|
||||
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
# Constants
|
||||
|
||||
INTRODUCTION = r"""<!--
|
||||
|
||||
This document is auto-generated with `make license`.
|
||||
To update it, edit (paths relative to Blender projects root):
|
||||
|
||||
* Introduction and formatting: ./tools/utils_maintenance/make_license.py
|
||||
* External libraries: ./build_files/build_environment/cmake/versions.cmake
|
||||
* Internal libraries: ./extern/*/Blender.README
|
||||
* Fonts: ./tools/utils_maintenance/make_license.py
|
||||
* New licenses: ./release/license/licenses.json
|
||||
|
||||
Then run `make license` and commit `license.md`.
|
||||
|
||||
-->
|
||||
# Blender Third-Party Licenses
|
||||
|
||||
While Blender itself is released under [GPU-GPL 3.0 or later](https://spdx.org/licenses/GPL-3.0-or-later.html)
|
||||
`© 2011-<THIS-YEAR> Blender Foundation`,
|
||||
it contains dependencies which have different licenses.
|
||||
|
||||
<SPDX:GPL-3.0-or-later>
|
||||
|
||||
""".replace("<THIS-YEAR>", str(datetime.date.today().year))
|
||||
|
||||
INTRODUCTION += r"""
|
||||
## Fonts
|
||||
|
||||
Blender distributes a number of font files to support many different language and uses.
|
||||
They work together as a stack.
|
||||
|
||||
| Font | License | Copyright |
|
||||
| ------- | --------- | ------- |
|
||||
| [Inter](https://rsms.me/inter/) | <SPDX:OFL-1.1|link> | `Copyright 2020 The Inter Project Authors (https://github.com/rsms/inter)` |
|
||||
| [Noto Fonts](https://fonts.google.com/noto) | <SPDX:OFL-1.1|link> | `Copyright 2018 The Noto Project Authors (github.com/googlei18n/noto-fonts)`|
|
||||
| [Last Resort](https://github.com/unicode-org/last-resort-font) | <SPDX:OFL-1.1|link> | `Copyright © 1998-2024 Unicode, Inc. Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the United States and other countries.` |
|
||||
| [DejaVu Sans Mono](https://github.com/dejavu-fonts/dejavu-fonts) | <Arev-Fonts|link> + <SPDX:Bitstream-Vera|link> | `2003 Bitstream, Inc. (Bitstream font glyphs). 2006 Tavmjong Bah (Arev font glyphs). DejaVu changes are in public domain` |
|
||||
|
||||
<Arev-Fonts>
|
||||
<SPDX:Bitstream-Vera>
|
||||
<SPDX:OFL-1.1>
|
||||
"""
|
||||
|
||||
|
||||
NO_LICENSE = "No License Set"
|
||||
|
||||
LICENSES_NOT_NEEDED = {
|
||||
"",
|
||||
}
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
# Types
|
||||
|
||||
|
||||
# Raw data extracted either from:
|
||||
# - `README.blender` files.
|
||||
# - `./build_files/build_environment/cmake/versions.cmake`.
|
||||
class LibraryRaw(NamedTuple):
|
||||
name: str
|
||||
homepage: str
|
||||
version: str
|
||||
license: str
|
||||
exception: str
|
||||
copyright: str
|
||||
|
||||
|
||||
def int_to_superscript(num: int) -> str:
|
||||
# Mapping of regular digits to superscript Unicode characters.
|
||||
superscript_map = {
|
||||
"0": "⁰",
|
||||
"1": "¹",
|
||||
"2": "²",
|
||||
"3": "³",
|
||||
"4": "⁴",
|
||||
"5": "⁵",
|
||||
"6": "⁶",
|
||||
"7": "⁷",
|
||||
"8": "⁸",
|
||||
"9": "⁹"
|
||||
}
|
||||
# Convert the integer to a string and map each digit to its superscript equivalent.
|
||||
return "".join(superscript_map[digit] for digit in str(num))
|
||||
|
||||
|
||||
class Library:
|
||||
__slots__ = ("name", "version", "homepage", "library_copyright", "exception")
|
||||
|
||||
name: str
|
||||
version: str
|
||||
homepage: str
|
||||
library_copyright: str
|
||||
exception: str
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
*,
|
||||
name: str,
|
||||
version: str,
|
||||
homepage: str,
|
||||
library_copyright: str,
|
||||
exception: str,
|
||||
):
|
||||
# pylint: disable=too-many-arguments
|
||||
self.name = name
|
||||
self.version = version
|
||||
self.homepage = homepage
|
||||
self.library_copyright = library_copyright
|
||||
self.exception = exception
|
||||
|
||||
def __lt__(self, other: "Library") -> bool:
|
||||
return self.name.lower() < other.name.lower()
|
||||
|
||||
def check_missing_copyright(self, library_license: "License") -> None:
|
||||
"""Some licenses require a copyright notice"""
|
||||
if self.library_copyright or library_license.copyright_exemption:
|
||||
return
|
||||
|
||||
print(f"Warning: \"{self.name}\" missing copyright notice "
|
||||
f"(required for {library_license.identifier}).")
|
||||
|
||||
def dump(self, library_license: "License") -> str:
|
||||
self.check_missing_copyright(library_license)
|
||||
|
||||
library_copyright = f"`{self.library_copyright}`" if self.library_copyright else "-"
|
||||
name = f"[{self.name}]({self.homepage})" if self.homepage else self.name
|
||||
version = self.version[:11] if self.version else "-"
|
||||
|
||||
# Add exception indicator in the name.
|
||||
name += library_license.get_exception_suffix(self.exception)
|
||||
raw_data = (
|
||||
f"| {name} "
|
||||
f"| {version} "
|
||||
)
|
||||
|
||||
if not library_license.copyright_exemption:
|
||||
raw_data += f"| {library_copyright} "
|
||||
|
||||
raw_data += "|\n"
|
||||
return raw_data
|
||||
|
||||
|
||||
class License:
|
||||
__slots__ = ("identifier", "name", "url", "copyright_exemption", "libraries", "exceptions")
|
||||
|
||||
identifier: str
|
||||
name: str
|
||||
url: str
|
||||
copyright_exemption: str
|
||||
libraries: list[Library]
|
||||
exceptions: list[str]
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
*,
|
||||
identifier: str,
|
||||
name: str,
|
||||
url: str,
|
||||
copyright_exemption: str = "",
|
||||
):
|
||||
self.identifier = identifier
|
||||
self.name = name
|
||||
self.url = url
|
||||
# By default we assume that all the licenses require copyright.
|
||||
self.copyright_exemption = copyright_exemption
|
||||
self.libraries = []
|
||||
self.exceptions = []
|
||||
|
||||
@property
|
||||
def filepath(self) -> str:
|
||||
if self.identifier.startswith("SPDX"):
|
||||
filepath = os.path.join(DIRPATH_LICENSES, "spdx", f"{self.identifier[5:]}.txt")
|
||||
else:
|
||||
filepath = os.path.join(DIRPATH_LICENSES, "others", f"{self.identifier}.txt")
|
||||
return filepath
|
||||
|
||||
def get_exception_suffix(self, exception: str) -> str:
|
||||
"""Return (optional) exception indicator e.g., ¹ """
|
||||
if not exception:
|
||||
return ""
|
||||
|
||||
if exception not in self.exceptions:
|
||||
self.exceptions.append(exception)
|
||||
|
||||
_id = self.exceptions.index(exception)
|
||||
return int_to_superscript(_id + 1)
|
||||
|
||||
def dump(self, index: int = 0) -> str:
|
||||
"""Read the complete license file from disk and return as string
|
||||
"""
|
||||
# Make sure we only throw the error if we actually need the file.
|
||||
# If there are no libraries using this license, there is no need to complain.
|
||||
# The json could even have all the licenses from SPDX and only include the ones
|
||||
# Blender needs.
|
||||
if not os.path.exists(self.filepath):
|
||||
if self.copyright_exemption:
|
||||
return ""
|
||||
|
||||
print(f"Error: Could not find license file for {self.identifier}: \"{self.filepath}\"")
|
||||
sys.exit(1)
|
||||
|
||||
with open(self.filepath, "r", encoding="utf8") as fh:
|
||||
license_raw = fh.read()
|
||||
|
||||
# Strip trailing space as this has a special meaning for mark-down,
|
||||
# avoid editing the original texts as any edits may be overwritten
|
||||
# when updating the licenses.
|
||||
#
|
||||
# This also removes page breaks "\x0C" or ^L.
|
||||
# These could be replaced with sometime similar in markdown,
|
||||
# unless this has some benefit, leave as-is.
|
||||
license_raw = "\n".join(line.rstrip() for line in license_raw.split("\n"))
|
||||
|
||||
# Debug option commented out.
|
||||
# This is useful if you want a document for human inspection without the licenses.
|
||||
# license_raw = "# Debug"
|
||||
|
||||
summary_prefix = f"{int_to_superscript(index)} " if index else ""
|
||||
library_license = (
|
||||
f"<details>\n<summary>{summary_prefix}{self.name}</summary>\n"
|
||||
f"\n{license_raw}\n"
|
||||
"</details>"
|
||||
)
|
||||
|
||||
return library_license
|
||||
|
||||
def __lt__(self, other: "License") -> bool:
|
||||
return self.name.lower() < other.name.lower()
|
||||
|
||||
def __repr__(self) -> str:
|
||||
as_dict = {
|
||||
self.identifier: {
|
||||
"name": self.name,
|
||||
"url": self.url,
|
||||
"filepath": self.filepath,
|
||||
"libraries": len(self.libraries),
|
||||
}
|
||||
}
|
||||
return json.dumps(as_dict, indent=2)
|
||||
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
# Internal Logic
|
||||
|
||||
def initialize_licenses() -> dict[str, License]:
|
||||
with open(FILEPATH_LICENSES_INDEX, "r", encoding="utf8") as fh:
|
||||
licenses_json = json.load(fh)
|
||||
|
||||
licenses = {key: License(identifier=key, **values) for key, values in licenses_json.items()}
|
||||
return licenses
|
||||
|
||||
|
||||
def get_license_exception(library_license: str) -> tuple[str, str]:
|
||||
"""Split license into main license and exception
|
||||
|
||||
Example of acceptable license: "SPDX:Apache-2.0 WITH LLVM-exception"
|
||||
This would output: ("SPDX:Apache-2.0", "LLVM-exception")
|
||||
"""
|
||||
# Use `re.IGNORECASE` to match "with" in any case (e.g., "with" or "WITH").
|
||||
re_match = re.match(r"^(.*)\swith\s(.+)$", library_license, re.IGNORECASE)
|
||||
if re_match:
|
||||
return re_match.group(1).strip(), re_match.group(2).strip()
|
||||
return library_license, ""
|
||||
|
||||
|
||||
def flatten_cmake_file(content: str) -> str:
|
||||
"""Resolve all the ${VARIABLES} in CMake"""
|
||||
# Find all variable definitions of the form `set(VAR_NAME VALUE)`.
|
||||
variables = dict(re.findall(r"set\((\w+)\s+([^\)]+)\)", content))
|
||||
|
||||
# Replace all occurrences of ${VAR_NAME} with the corresponding value.
|
||||
for var, value in variables.items():
|
||||
content = re.sub(rf"\$\{{{var}\}}", value, content)
|
||||
return content
|
||||
|
||||
|
||||
def process_versions_cmake() -> Iterator[LibraryRaw]:
|
||||
"""
|
||||
Parse versions.cmake
|
||||
|
||||
Return a dictionary grouped by license.
|
||||
"""
|
||||
# pylint: disable=too-many-locals
|
||||
|
||||
# NOTE(@ideasman42): basic & imperfect variable extractions.
|
||||
# It can be fairly easily tripped up by expressions such as:
|
||||
# - `set(VAR "VALUE ) # ")`
|
||||
# - Uppercase or additional spaces e.g. `SET (...)`.
|
||||
# - Or `set()` expressions inside a multi-line string.
|
||||
#
|
||||
# Any effort to rewrite this logic would be better spent running the file through CMake it's self,
|
||||
# appending logic to dump all variables using `string(JSON ...)` which Python can then read reliably.
|
||||
|
||||
libraries_raw: dict[str, dict[str, str]] = {}
|
||||
with open(FILEPATH_VERSIONS_CMAKE, "r", encoding="utf8") as fh:
|
||||
data = fh.read()
|
||||
|
||||
data = flatten_cmake_file(data)
|
||||
for re_match in re.finditer(r"^set\((\w+)\s+", data, re.MULTILINE):
|
||||
# Use regex to capture the key from each set() statement.
|
||||
# Extract the value from the remainder.
|
||||
key = re_match.group(1)
|
||||
value_start = re_match.end()
|
||||
value_eol = data.find("\n", value_start)
|
||||
assert value_eol != -1
|
||||
value_line = data[value_start: value_eol].rstrip()
|
||||
|
||||
# Strip any comments at the line end.
|
||||
# `set(FOO BAR) # BAZ`.
|
||||
if (re_match_comment := next(re.finditer(r"\)\s*#", value_line), None)):
|
||||
value_line = value_line[:re_match_comment.start() + 1]
|
||||
|
||||
# Extract the value by checking this line and detecting single or multi-line text.
|
||||
if value_line.endswith(")"):
|
||||
# Single line variable.
|
||||
value = value_line[:-1].strip()
|
||||
elif value_line.endswith("[=["):
|
||||
# Calculate the bounds of the multi-line string.
|
||||
value_ml_start = value_start + len(value_line)
|
||||
value_ml_end = data.find("]=]", value_ml_start)
|
||||
assert value_ml_end != -1
|
||||
value = data[value_ml_start:value_ml_end].strip().replace("\n", " ")
|
||||
else:
|
||||
# Could not detect a single line value OR a multi-line value.
|
||||
print(f"Error: Unable to parse {key!r}, line {value_line!r}, "
|
||||
"expected an \")\" ending or beginning of a multi-line string \"[=[\"")
|
||||
sys.exit(1)
|
||||
|
||||
# Determine the library name from the prefix (minus the suffix).
|
||||
library_name, end_word = key.rpartition("_")[0::2]
|
||||
if not library_name:
|
||||
# No suffix to check, it can be skipped.
|
||||
continue
|
||||
|
||||
# Initialize the library entry if it doesn't exist.
|
||||
if (library_vars := libraries_raw.get(library_name)) is None:
|
||||
library_vars = libraries_raw[library_name] = {
|
||||
"name": library_name.replace("_", " ").title(),
|
||||
"homepage": "",
|
||||
"version": "",
|
||||
"license": "",
|
||||
"exception": "",
|
||||
"copyright": "",
|
||||
# Exclude from `LibraryRaw`.
|
||||
"_hash": "",
|
||||
"_build_time_only": "",
|
||||
}
|
||||
|
||||
# Populate the relevant fields based on the key.
|
||||
match end_word:
|
||||
case "NAME":
|
||||
library_vars["name"] = value.strip('"')
|
||||
case "HOMEPAGE":
|
||||
library_vars["homepage"] = value.strip('"')
|
||||
case "VERSION":
|
||||
library_vars["version"] = value.strip('"')
|
||||
case "LICENSE":
|
||||
library_license, exception = get_license_exception(value)
|
||||
library_vars["license"] = library_license
|
||||
library_vars["exception"] = exception
|
||||
case "COPYRIGHT":
|
||||
library_vars["copyright"] = value.strip('"')
|
||||
case "HASH":
|
||||
library_vars["_hash"] = value
|
||||
case "DEPSBUILDTIMEONLY":
|
||||
# Use only strings to simplify the type-checking.
|
||||
library_vars["_build_time_only"] = "True"
|
||||
|
||||
# If there is no hash we assume it is not a real library but some other information on the file.
|
||||
# Also remove any library which is only used during build time and have no
|
||||
# artifact included in the final Blender binary.
|
||||
for key, lib_info_args in libraries_raw.items():
|
||||
if not (lib_info_args["_hash"] and not lib_info_args["_build_time_only"]):
|
||||
continue
|
||||
yield LibraryRaw(**{k: v for k, v in lib_info_args.items() if not k.startswith("_")})
|
||||
|
||||
|
||||
def iterate_readme_files(base_dir: Path) -> Iterator[str]:
|
||||
base_path = Path(base_dir)
|
||||
|
||||
# Iterate over all subdirectories.
|
||||
for subdir in base_path.iterdir():
|
||||
if not subdir.is_dir():
|
||||
continue
|
||||
|
||||
readme_path = subdir / "README.blender"
|
||||
if not readme_path.exists():
|
||||
print(f"Warning: Missing file \"{readme_path}\"")
|
||||
continue
|
||||
|
||||
with readme_path.open("r", encoding="utf8") as fh:
|
||||
contents = fh.read()
|
||||
yield contents
|
||||
|
||||
|
||||
def process_readme_blender() -> Iterator[LibraryRaw]:
|
||||
""""Handle the README.blender files"""
|
||||
keys = {
|
||||
"Project": "name",
|
||||
"URL": "homepage",
|
||||
"License": "license",
|
||||
"Upstream version": "version",
|
||||
"Copyright": "copyright"
|
||||
}
|
||||
|
||||
for readme in iterate_readme_files(DIRPATH_EXTERN_LIBRARIES):
|
||||
lines = readme.strip().split("\n")
|
||||
|
||||
# Temporary storage for project fields.
|
||||
project_fields = {}
|
||||
|
||||
for line in lines:
|
||||
line_split = line.split(":", 1)
|
||||
|
||||
# Ignore comments and empty lines.
|
||||
if len(line_split) != 2:
|
||||
continue
|
||||
|
||||
key, value = line_split
|
||||
key = key.strip()
|
||||
value = value.strip().strip('"')
|
||||
|
||||
# Check if the current line matches one of the provided keys.
|
||||
if key in keys:
|
||||
project_fields[keys[key]] = value
|
||||
|
||||
# Assign the fields to the project name.
|
||||
project_name = project_fields.get("name", "Unknown Project")
|
||||
|
||||
# Split the license into license and its (optional) extension.
|
||||
library_license, exception = get_license_exception(project_fields.get("license", ""))
|
||||
|
||||
yield LibraryRaw(
|
||||
name=project_name,
|
||||
version=project_fields.get("version", ""),
|
||||
homepage=project_fields.get("homepage", ""),
|
||||
license=library_license,
|
||||
exception=exception,
|
||||
copyright=project_fields.get("copyright", ""),
|
||||
)
|
||||
|
||||
|
||||
def fetch_libraries_licenses() -> dict[str, License]:
|
||||
"""Populate the licenses dict with its corresponding libraries and copyrights"""
|
||||
|
||||
licenses = initialize_licenses()
|
||||
|
||||
# Intermediate storage.
|
||||
|
||||
# Map the license name to all libraries that use it.
|
||||
# Keys may be: `SPDX:GPL-2.0-or-later`, `SPDX:MIT`, ... `ICS` etc.
|
||||
licenses_data: dict[str, list[LibraryRaw]] = {}
|
||||
|
||||
for lib_info in itertools.chain(
|
||||
# Get data from `./build_files/build_environment/cmake/versions.cmake`.
|
||||
process_versions_cmake(),
|
||||
# Get data from `README.blender` files.
|
||||
process_readme_blender(),
|
||||
):
|
||||
license_name = lib_info.license or NO_LICENSE
|
||||
if (libraries_data := licenses_data.get(license_name)) is None:
|
||||
libraries_data = licenses_data[license_name] = []
|
||||
libraries_data.append(lib_info)
|
||||
|
||||
# Populate licenses with the corresponding libraries.
|
||||
for license_key, libraries_data in licenses_data.items():
|
||||
if license_key == NO_LICENSE:
|
||||
print("Warning: The following libraries have no license:")
|
||||
for lib_info in libraries_data:
|
||||
print(f" * {lib_info.name}")
|
||||
continue
|
||||
if license_key in LICENSES_NOT_NEEDED:
|
||||
# Do nothing about these licenses.
|
||||
continue
|
||||
if (license_obj := licenses.get(license_key)) is None:
|
||||
# Do nothing about these licenses.
|
||||
print(f"Error: {license_key} license not found in: \"{FILEPATH_LICENSES_INDEX}\"")
|
||||
continue
|
||||
|
||||
for lib_info in libraries_data:
|
||||
library = Library(
|
||||
name=lib_info.name,
|
||||
version=lib_info.version,
|
||||
homepage=lib_info.homepage,
|
||||
library_copyright=lib_info.copyright,
|
||||
exception=lib_info.exception,
|
||||
)
|
||||
license_obj.libraries.append(library)
|
||||
|
||||
return licenses
|
||||
|
||||
|
||||
def extract_licenses(text: str) -> set[str]:
|
||||
"""Extract all the licenses from the text
|
||||
|
||||
Licenses are defined under <>, and |link is ignored.
|
||||
|
||||
For example, for the input:
|
||||
* <SPDX:GPL-3.0-or-later|link>
|
||||
* <Example-Fonts>
|
||||
|
||||
The output would be:
|
||||
{"SPDX:GPL-3.0-or-later", "Example-Fonts"}
|
||||
"""
|
||||
# Remove multi-line comments (<!-- ... -->).
|
||||
text = re.sub(r"<!--.*?-->", "", text, flags=re.DOTALL)
|
||||
|
||||
# Find all licenses in < >.
|
||||
license_pattern = r"<([^<|>]+?)>"
|
||||
|
||||
# Find all matches.
|
||||
matches = re.findall(license_pattern, text)
|
||||
|
||||
# Extract unique licenses while ignoring emails.
|
||||
licenses = {match.strip() for match in matches if "@" not in match}
|
||||
|
||||
return licenses
|
||||
|
||||
|
||||
def get_introduction(licenses: dict[str, License]) -> str:
|
||||
introduction = INTRODUCTION
|
||||
license_lookups = extract_licenses(INTRODUCTION)
|
||||
|
||||
for license_lookup in license_lookups:
|
||||
if license_lookup not in licenses:
|
||||
print(f"Error: {license_lookup} license not found in: \"{FILEPATH_LICENSES_INDEX}\"")
|
||||
continue
|
||||
|
||||
license_item = licenses[license_lookup]
|
||||
introduction = introduction.replace(
|
||||
f"<{license_lookup}>",
|
||||
license_item.dump()
|
||||
)
|
||||
|
||||
introduction = introduction.replace(
|
||||
f"<{license_lookup}|link>",
|
||||
f"[{license_item.name}]({license_item.url})"
|
||||
)
|
||||
|
||||
return introduction
|
||||
|
||||
|
||||
def generate_license_file(licenses: dict[str, License]) -> None:
|
||||
filepath = FILEPATH_LICENSE_GENERATED
|
||||
|
||||
with open(filepath, "w", encoding="utf8") as fh:
|
||||
fh.write(get_introduction(licenses))
|
||||
|
||||
for license_item in sorted(licenses.values()):
|
||||
if len(license_item.libraries) == 0:
|
||||
continue
|
||||
|
||||
if license_item.url:
|
||||
fh.write(f"\n\n## [{license_item.name}]({license_item.url})\n\n")
|
||||
else:
|
||||
fh.write(f"\n\n## {license_item.name}\n\n")
|
||||
|
||||
if license_item.copyright_exemption:
|
||||
fh.write(f"{license_item.copyright_exemption}\n\n")
|
||||
fh.write("| Library | Version |\n")
|
||||
fh.write("| ------- | ------- |\n")
|
||||
else:
|
||||
fh.write("| Library | Version | Copyright |\n")
|
||||
fh.write("| ------- | ------- | --------- |\n")
|
||||
|
||||
for library in sorted(license_item.libraries):
|
||||
fh.write(library.dump(license_item))
|
||||
|
||||
fh.write(license_item.dump())
|
||||
for i, exception in enumerate(license_item.exceptions):
|
||||
exception_license = licenses.get(exception)
|
||||
|
||||
if exception_license is None:
|
||||
print(f"Error: {exception} extension license not found in: \"{FILEPATH_LICENSES_INDEX}\"")
|
||||
continue
|
||||
|
||||
fh.write(exception_license.dump(i + 1))
|
||||
fh.write("\n")
|
||||
|
||||
print(f"\nLicense file successfully generated: \"{filepath}\"")
|
||||
print("Remember to commit the file to the Blender repository.\n")
|
||||
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
# Main Function
|
||||
|
||||
|
||||
def main() -> None:
|
||||
licenses = fetch_libraries_licenses()
|
||||
|
||||
generate_license_file(licenses)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user