1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
|
# Copyright 2025 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
from typing import Dict, List, Union
import metadata_dictionary
import constants
from license_type import LicenseType
def get_most_restrictive_type(licenses_names: List[str]) -> LicenseType:
"""Returns the most restrictive license according to the values of LicenseType."""
most_restrictive = LicenseType.UNKNOWN
for license_name in licenses_names:
if constants.RAW_LICENSE_TO_FORMATTED_DETAILS[license_name][
1].value > most_restrictive.value:
most_restrictive = constants.RAW_LICENSE_TO_FORMATTED_DETAILS[
license_name][1]
return most_restrictive
class Metadata:
def __init__(self, metadata_dict: Dict[str, Union[str, List[str]]]):
self.metadata = metadata_dict
def get_name(self) -> str:
return self.metadata["Name"]
def get_url(self) -> str:
return self.metadata["URL"]
def get_version(self):
if not self._get_version() or self._get_version() in [
"0", "unknown", "N/A"
]:
# This is a heuristic try to avoid putting a version when the version
# in the README.chromium does not make any sense.
return self._get_revision()
return self._get_version()
def _get_version_control(self):
"""Returns the VCS of the URL provided if possible,
otherwise None is returned."""
if "git" in self.get_url() or "googlesource" in self.get_url():
return "Git"
if "hg" in self.get_url():
return "Hg"
return None
def _create_identifier_block(
self) -> metadata_dictionary.MetadataDictionary:
identifier_dictionary = metadata_dictionary.MetadataDictionary(
"identifier")
identifier_dictionary["value"] = f"\"{self.get_url()}\""
identifier_dictionary["type"] = f"\"{self._get_version_control()}\""
if self.get_version():
identifier_dictionary["version"] = f"\"{self.get_version()}\""
return identifier_dictionary
def _get_version(self) -> str:
return self.metadata.get("Version", None)
def _get_revision(self) -> str:
return self.metadata.get("Revision", None)
def get_licenses(self) -> List[str]:
return self.metadata["License"]
def get_license_file_path(self) -> str:
return self.metadata.get("License File", [None])[0]
def get_license_type(self) -> LicenseType:
return get_most_restrictive_type(self.get_licenses())
def to_android_metadata(self):
third_party_dict = metadata_dictionary.MetadataDictionary(
"third_party")
third_party_dict["license_type"] = self.get_license_type().name
if self.get_version():
third_party_dict["version"] = f"\"{self.get_version()}\""
if self._get_version_control():
third_party_dict[
"identifier_primary"] = self._create_identifier_block()
else:
third_party_dict["homepage"] = f"\"{self.get_url()}\""
return "\n".join(
[f"name: \"{self.get_name()}\"", f"{third_party_dict}"])
|
