diff --git a/generateJava.py b/generateJava.py index 2b3f218..6a0bfc1 100644 --- a/generateJava.py +++ b/generateJava.py @@ -124,13 +124,13 @@ def mojang_os_to_java_os(mojang_os: MojangJavaOsName) -> JavaRuntimeOS: def mojang_runtime_to_java_runtime( mojang_runtime: MojangJavaRuntime, + mojang_component: MojangJavaComponent, ) -> JavaRuntimeMeta: major, _, security = mojang_runtime.version.name.partition("u") if major and security: version_parts = [int(major), 0, int(security)] else: - version_parts = [int(part) - for part in mojang_runtime.version.name.split(".")] + version_parts = [int(part) for part in mojang_runtime.version.name.split(".")] while len(version_parts) < 3: version_parts.append(0) @@ -147,7 +147,7 @@ def mojang_runtime_to_java_runtime( name=mojang_runtime.version.name, ) return JavaRuntimeMeta( - name=f"mojang_jre_{mojang_runtime.version.name}", + name=mojang_component, vendor="mojang", url=mojang_runtime.manifest.url, releaseTime=mojang_runtime.version.released, @@ -177,7 +177,9 @@ def adoptium_release_binary_to_java_runtime( version = JavaVersionMeta( major=rls.version_data.major if rls.version_data.major is not None else 0, minor=rls.version_data.minor if rls.version_data.minor is not None else 0, - security=rls.version_data.security if rls.version_data.security is not None else 0, + security=rls.version_data.security + if rls.version_data.security is not None + else 0, build=rls.version_data.build, ) rls_name = f"{rls.vendor}_temurin_{binary.image_type}{version}" @@ -217,9 +219,7 @@ def azul_package_to_java_runtime(pkg: ZuluPackageDetail) -> JavaRuntimeMeta: checksum = None if pkg.sha256_hash is not None: - checksum = JavaChecksumMeta( - type=JavaChecksumType.Sha256, hash=pkg.sha256_hash - ) + checksum = JavaChecksumMeta(type=JavaChecksumType.Sha256, hash=pkg.sha256_hash) return JavaRuntimeMeta( name=rls_name, @@ -262,7 +262,9 @@ def pkg_type_priority(pkg_type: JavaPackageType) -> int: return -1 -def ensure_one_recommended(runtimes: list[JavaRuntimeMeta]) -> Optional[JavaRuntimeMeta]: +def ensure_one_recommended( + runtimes: list[JavaRuntimeMeta], +) -> Optional[JavaRuntimeMeta]: if len(runtimes) < 1: return None # can't do anything @@ -287,7 +289,9 @@ def ensure_one_recommended(runtimes: list[JavaRuntimeMeta]) -> Optional[JavaRunt assert recommended is not None if vendor_priority(runtime.vendor) < vendor_priority(recommended.vendor): return False - if pkg_type_priority(runtime.package_type) < pkg_type_priority(recommended.package_type): + if pkg_type_priority(runtime.package_type) < pkg_type_priority( + recommended.package_type + ): return False if runtime.version < recommended.version: return False @@ -313,8 +317,7 @@ def main(): def add_java_runtime(runtime: JavaRuntimeMeta, major: int, java_os: JavaRuntimeOS): ensure_javamap(major) - print( - f"Regestering runtime: {runtime.name} for Java {major} {java_os}") + print(f"Regestering runtime: {runtime.name} for Java {major} {java_os}") javas[major][java_os].append(runtime) print("Processing Mojang Javas") @@ -334,68 +337,67 @@ def main(): major = 8 else: major = int(mojang_runtime.version.name.partition(".")[0]) - runtime = mojang_runtime_to_java_runtime(mojang_runtime) + runtime = mojang_runtime_to_java_runtime(mojang_runtime, comp) add_java_runtime(runtime, major, java_os) print("Processing Adoptium Releases") - adoptium_available_releases = AdoptiumAvailableReleases.parse_file( - os.path.join(UPSTREAM_DIR, ADOPTIUM_DIR, "available_releases.json") - ) - for major in adoptium_available_releases.available_releases: - adoptium_releases = AdoptiumReleases.parse_file( - os.path.join(UPSTREAM_DIR, ADOPTIUM_VERSIONS_DIR, - f"java{major}.json") + adoptium_path = os.path.join(UPSTREAM_DIR, ADOPTIUM_DIR, "available_releases.json") + if os.path.exists(adoptium_path): + adoptium_available_releases = AdoptiumAvailableReleases.parse_file( + adoptium_path ) - for _, rls in adoptium_releases: - for binary in rls.binaries: - if binary.package is None: - continue - binary_arch = translate_arch(str(binary.architecture)) - binary_os = translate_os(str(binary.os)) - if binary_arch is None or binary_os is None: - print( - f"Ignoring release for {binary.os} {binary.architecture}") - continue + for major in adoptium_available_releases.available_releases: + adoptium_releases = AdoptiumReleases.parse_file( + os.path.join(UPSTREAM_DIR, ADOPTIUM_VERSIONS_DIR, f"java{major}.json") + ) + for _, rls in adoptium_releases: + for binary in rls.binaries: + if binary.package is None: + continue + binary_arch = translate_arch(str(binary.architecture)) + binary_os = translate_os(str(binary.os)) + if binary_arch is None or binary_os is None: + print(f"Ignoring release for {binary.os} {binary.architecture}") + continue - java_os = JavaRuntimeOS(f"{binary_os}-{binary_arch}") - runtime = adoptium_release_binary_to_java_runtime(rls, binary) - add_java_runtime(runtime, major, java_os) + java_os = JavaRuntimeOS(f"{binary_os}-{binary_arch}") + runtime = adoptium_release_binary_to_java_runtime(rls, binary) + add_java_runtime(runtime, major, java_os) print("Processing Azul Packages") - azul_packages = ZuluPackageList.parse_file( - os.path.join(UPSTREAM_DIR, AZUL_DIR, "packages.json") - ) - for _, pkg in azul_packages: - pkg_detail = ZuluPackageDetail.parse_file( - os.path.join(UPSTREAM_DIR, AZUL_VERSIONS_DIR, - f"{pkg.package_uuid}.json") - ) - major = pkg_detail.java_version[0] - if major < 8: - continue # we will never need java versions less than 8 - - pkg_os = translate_os(str(pkg_detail.os)) - if pkg_detail.arch == AzulArch.Arm: - pkg_arch = translate_arch( - f"{pkg_detail.arch}{pkg_detail.hw_bitness}") - elif pkg_detail.arch == AzulArch.X86: - pkg_arch = translate_arch(int(pkg_detail.hw_bitness)) - else: - pkg_arch = None - if pkg_arch is None or pkg_os is None: - print( - f"Ignoring release for {pkg_detail.os} {pkg_detail.arch}_{pkg_detail.hw_bitness}" + azul_path = os.path.join(UPSTREAM_DIR, AZUL_DIR, "packages.json") + if os.path.exists(azul_path): + azul_packages = ZuluPackageList.parse_file(azul_path) + for _, pkg in azul_packages: + pkg_detail = ZuluPackageDetail.parse_file( + os.path.join( + UPSTREAM_DIR, AZUL_VERSIONS_DIR, f"{pkg.package_uuid}.json" + ) ) - continue + major = pkg_detail.java_version[0] + if major < 8: + continue # we will never need java versions less than 8 - java_os = JavaRuntimeOS(f"{pkg_os}-{pkg_arch}") - runtime = azul_package_to_java_runtime(pkg_detail) - add_java_runtime(runtime, major, java_os) + pkg_os = translate_os(str(pkg_detail.os)) + if pkg_detail.arch == AzulArch.Arm: + pkg_arch = translate_arch(f"{pkg_detail.arch}{pkg_detail.hw_bitness}") + elif pkg_detail.arch == AzulArch.X86: + pkg_arch = translate_arch(int(pkg_detail.hw_bitness)) + else: + pkg_arch = None + if pkg_arch is None or pkg_os is None: + print( + f"Ignoring release for {pkg_detail.os} {pkg_detail.arch}_{pkg_detail.hw_bitness}" + ) + continue + + java_os = JavaRuntimeOS(f"{pkg_os}-{pkg_arch}") + runtime = azul_package_to_java_runtime(pkg_detail) + add_java_runtime(runtime, major, java_os) for major, runtimes in javas.items(): for java_os, runtime_list in runtimes: - print(f"Total runtimes for Java {major} {java_os}:", len( - runtime_list)) + print(f"Total runtimes for Java {major} {java_os}:", len(runtime_list)) rec = ensure_one_recommended(runtime_list) if rec is not None: print(f"Recomending {rec.name} for Java {major} {java_os}") @@ -405,27 +407,26 @@ def main(): return b return a - version_file = os.path.join( - LAUNCHER_DIR, JAVA_COMPONENT, f"java{major}.json") + version_file = os.path.join(LAUNCHER_DIR, JAVA_COMPONENT, f"java{major}.json") java_version = JavaRuntimeVersion( - name = f"Java {major}", - uid = JAVA_COMPONENT, - version = f"java{major}", + name=f"Java {major}", + uid=JAVA_COMPONENT, + version=f"java{major}", releaseTime=reduce( - newest_timestamp, - (runtime.release_time - for _, runtime_list in runtimes - for runtime in runtime_list - ), - None + newest_timestamp, + ( + runtime.release_time + for _, runtime_list in runtimes + for runtime in runtime_list ), - runtimes = runtimes) + None, + ), + runtimes=runtimes, + ) java_version.write(version_file) package = MetaPackage( - uid = JAVA_COMPONENT, - name = "Java Runtimes", - recommended = ["java8", "java17"] + uid=JAVA_COMPONENT, name="Java Runtimes", recommended=["java8", "java17"] ) package.write(os.path.join(LAUNCHER_DIR, JAVA_COMPONENT, "package.json")) diff --git a/meta/model/__init__.py b/meta/model/__init__.py index 733f78d..3d06f99 100644 --- a/meta/model/__init__.py +++ b/meta/model/__init__.py @@ -93,10 +93,10 @@ class GradleSpecifier: else: return False - def __lt__(self, other: 'GradleSpecifier'): + def __lt__(self, other: "GradleSpecifier"): return str(self) < str(other) - def __gt__(self, other: 'GradleSpecifier'): + def __gt__(self, other: "GradleSpecifier"): return str(self) > str(other) def __hash__(self): @@ -125,7 +125,7 @@ class GradleSpecifier: return cls(group, artifact, version, classifier, extension) @classmethod - def validate(cls, v: 'str | GradleSpecifier'): + def validate(cls, v: "str | GradleSpecifier"): if isinstance(v, cls): return v if isinstance(v, str): @@ -155,7 +155,7 @@ class MetaBase(pydantic.BaseModel): with open(file_path, "w") as f: f.write(self.json()) - def merge(self, other: 'MetaBase'): + def merge(self, other: "MetaBase"): """ Merge other object with self. - Concatenates lists @@ -179,14 +179,14 @@ class MetaBase(pydantic.BaseModel): elif isinstance(ours, set): ours |= theirs elif isinstance(ours, dict): - result = merge_dict(ours, copy.deepcopy(theirs)) # type: ignore + result = merge_dict(ours, copy.deepcopy(theirs)) # type: ignore setattr(self, key, result) elif MetaBase in get_all_bases(field.type_): ours.merge(theirs) else: setattr(self, key, theirs) - def __hash__(self): #type: ignore + def __hash__(self): # type: ignore return hash(self.json()) class Config: @@ -277,7 +277,7 @@ class MojangRule(MetaBase): class MojangRules(MetaBase): __root__: List[MojangRule] - def __iter__(self) -> Iterator[MojangRule]: #type: ignore + def __iter__(self) -> Iterator[MojangRule]: # type: ignore return iter(self.__root__) def __getitem__(self, item: int) -> MojangRule: @@ -319,6 +319,7 @@ class MetaVersion(Versioned): minecraft_arguments: Optional[str] = Field(alias="minecraftArguments") release_time: Optional[datetime] = Field(alias="releaseTime") compatible_java_majors: Optional[List[int]] = Field(alias="compatibleJavaMajors") + compatible_java_name: Optional[str] = Field(alias="compatibleJavaName") additional_traits: Optional[List[str]] = Field(alias="+traits") additional_tweakers: Optional[List[str]] = Field(alias="+tweakers") additional_jvm_args: Optional[List[str]] = Field(alias="+jvmArgs") diff --git a/meta/model/mojang.py b/meta/model/mojang.py index 48a5e5a..749ce7e 100644 --- a/meta/model/mojang.py +++ b/meta/model/mojang.py @@ -18,6 +18,9 @@ from . import ( SUPPORTED_LAUNCHER_VERSION = 21 SUPPORTED_COMPLIANCE_LEVEL = 1 DEFAULT_JAVA_MAJOR = 8 # By default, we should recommend Java 8 if we don't know better +DEFAULT_JAVA_NAME = ( + "jre-legacy" # By default, we should recommend Java 8 if we don't know better +) COMPATIBLE_JAVA_MAPPINGS = {16: [17]} """ @@ -318,10 +321,12 @@ class MojangVersion(MetaBase): raise Exception(f"Unsupported compliance level {self.compliance_level}") major = DEFAULT_JAVA_MAJOR + javaName = DEFAULT_JAVA_NAME if ( self.javaVersion is not None ): # some versions don't have this. TODO: maybe maintain manual overrides major = self.javaVersion.major_version + javaName = self.javaVersion.component compatible_java_majors = [major] if ( @@ -343,6 +348,7 @@ class MojangVersion(MetaBase): release_time=self.release_time, type=new_type, compatible_java_majors=compatible_java_majors, + compatible_java_name=javaName, additional_traits=addn_traits, main_jar=main_jar, )