diff options
| -rw-r--r-- | generateJava.py | 277 | ||||
| -rw-r--r-- | meta/common/java.py | 4 | ||||
| -rw-r--r-- | meta/model/enum.py | 32 | ||||
| -rw-r--r-- | meta/model/java.py | 207 | ||||
| -rw-r--r-- | meta/model/mojang.py | 64 | ||||
| -rw-r--r-- | updateJava.py | 41 | ||||
| -rwxr-xr-x | updateMojang.py | 2 |
7 files changed, 533 insertions, 94 deletions
diff --git a/generateJava.py b/generateJava.py new file mode 100644 index 0000000000..11a449ae9f --- /dev/null +++ b/generateJava.py @@ -0,0 +1,277 @@ +import copy +import hashlib +import os +from collections import defaultdict, namedtuple +from operator import attrgetter +from pprint import pprint +from packaging import version as pversion +from typing import Optional, List + +from meta.common import ensure_component_dir, launcher_path, upstream_path, static_path + +from meta.common.java import ( + JAVA_COMPONENT, + ADOPTIUM_DIR, + ADOPTIUM_VERSIONS_DIR, + AZUL_DIR, + AZUL_VERSIONS_DIR +) +from meta.model.java import ( + JavaRuntimeOS, + JavaRuntimeMap, + JavaRuntimeMeta, + JavaVersionMeta, + JavaChecksumMeta, + JavaChecksumType, + JavaRuntimeDownloadType, + AdoptiumAvailableReleases, + AdoptiumReleases, + AdoptiumRelease, + AdoptiumBinary, + ZuluPackages, + ZuluPackageDetail, + AzulArch, +) + +from meta.common.mojang import ( + + JAVA_MANIFEST_FILE, +) + +from meta.model.mojang import ( + JavaIndex, + MojangJavaComponent, + MojangJavaOsName, + MojangJavaRuntime, +) + +LAUNCHER_DIR = launcher_path() +UPSTREAM_DIR = upstream_path() +STATIC_DIR = static_path() + +ensure_component_dir(JAVA_COMPONENT) + +MOJANG_JAVA_OS_NAMES = [ + "gamecore", + "linux", + "linux-i386", + "mac-os", + "mac-os-arm64", + "windows-arm64", + "windows-x64", + "windows-x86", +] + +MOJANG_OS_ARCHITECTURES = [ + "x64", + "x86", + "arm64", + "arm32", +] + +MOJANG_OS_ARCHITECTURE_TRANSLATIONS = { + 64: "x64", + 32: "x86", + "x32": "x86", + "i386": "x86", + "aarch64": "arm64", + "x86_64": "x64", + "arm": "arm32" +} + + +def translate_arch(arch: str | int): + if isinstance(arch, str): + arch = arch.lower() + if arch in MOJANG_OS_ARCHITECTURES: + return arch + elif arch in MOJANG_OS_ARCHITECTURE_TRANSLATIONS: + return MOJANG_OS_ARCHITECTURE_TRANSLATIONS[arch] + else: + return None + +MOJANG_OS_NAMES = [ + "mac-os", + "linux", + "windows", +] + +MOJANG_OS_TRANSLATIONS = { + "osx": "mac-os", + "mac": "mac-os", + "macos": "mac-os", +} + +def translate_os(os: str): + os = os.lower() + if os in MOJANG_OS_NAMES: + return os + elif os in MOJANG_OS_TRANSLATIONS: + return MOJANG_OS_TRANSLATIONS[os] + else: + return None + + +def mojang_os_to_java_os(mojang_os: MojangJavaOsName) -> JavaRuntimeOS: + if mojang_os == MojangJavaOsName.Linux: + return JavaRuntimeOS.LinuxX64 + elif mojang_os == MojangJavaOsName.Linuxi386: + return JavaRuntimeOS.LinuxX86 + elif mojang_os == MojangJavaOsName.MacOs: + return JavaRuntimeOS.MacOsX64 + elif mojang_os == MojangJavaOsName.MacOSArm64: + return JavaRuntimeOS.MacOsArm64 + elif mojang_os == MojangJavaOsName.WindowsArm64: + return JavaRuntimeOS.WindowsArm64 + elif mojang_os == MojangJavaOsName.WindowsX64: + return JavaRuntimeOS.WindowsX64 + elif mojang_os == MojangJavaOsName.WindowsX86: + return JavaRuntimeOS.WindowsX86 + else: + return JavaRuntimeOS.Unknown + + +def mojang_runtime_to_java_runtime(mojang_runtime: MojangJavaRuntime) -> JavaRuntimeMeta: + return JavaRuntimeMeta( + name=f"mojang_jre_{mojang_runtime.version.name}", + vender="mojang", + url=mojang_runtime.manifest.url, + release_time=mojang_runtime.version.released, + checksum=JavaChecksumMeta( + type=JavaChecksumType.Sha1, + hash=mojang_runtime.manifest.sha1), + recomended=True, + download_type=JavaRuntimeDownloadType.Manifest) + +def adoptium_release_binary_to_java_runtime(rls: AdoptiumRelease, binary: AdoptiumBinary) -> JavaRuntimeMeta: + version = JavaVersionMeta( + major=rls.version_data.major, + minor=rls.version_data.minor, + security=rls.version_data.security, + build=rls.version_data.build + ) + rls_name = f"{rls.vendor}_temurin_{binary.image_type}{version}" + return JavaRuntimeMeta( + name=rls_name, + vender=rls.vendor, + url=binary.package.link, + release_time=rls.timestamp, + checksum=JavaChecksumMeta( + type=JavaChecksumType.Sha256, + hash=binary.package.checksum), + recomended=False, + download_type=JavaRuntimeDownloadType.Archive + ) + +def azul_package_to_java_runtime(pkg: ZuluPackageDetail) -> JavaRuntimeMeta: + version_parts = copy.copy(pkg.java_version) + while len(version_parts) < 4: + version_parts.append(None) + + version = JavaVersionMeta( + major=version_parts[0], + minor=version_parts[1], + security=version_parts[2], + build=version_parts[3] + ) + + rls_name = f"azul_{pkg.product}_{pkg.java_package_type}{version}" + + return JavaRuntimeMeta( + name=rls_name, + vender="azul", + url=pkg.download_url, + release_time=pkg.build_date, + checksum=JavaChecksumMeta( + type=JavaChecksumType.Sha256, + hash=pkg.sha256_hash), + recomended=False, + download_type=JavaRuntimeDownloadType.Archive + ) + +def main(): + + javas: dict[int, JavaRuntimeMap] = {} + + def ensure_javamap(major: int): + if major not in javas: + javas[major] = JavaRuntimeMap() + + 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}") + javas[major][java_os].append(runtime) + + print("Processing Mojang Javas") + mojang_java_manifest = JavaIndex.parse_file( + os.path.join(UPSTREAM_DIR, JAVA_MANIFEST_FILE) + ) + for mojang_os_name in mojang_java_manifest: + if mojang_os_name == MojangJavaOsName.Gamecore: + continue + java_os = mojang_os_to_java_os(mojang_os_name) + for comp in mojang_java_manifest[mojang_os_name]: + mojang_runtimes = mojang_java_manifest[mojang_os_name][comp] + for mojang_runtime in mojang_runtimes: + if comp == MojangJavaComponent.JreLegacy: + major = 8 + else: + major = int(mojang_runtime.version.name.partition('.')[0]) + runtime = mojang_runtime_to_java_runtime(mojang_runtime) + 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") + ) + 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) + + print("Processing Azul Packages") + azul_packages = ZuluPackages.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] + 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 in runtimes: + print(f"Total runtimes for Java {major} {java_os}:", len(runtimes[java_os])) + runtimes_file = os.path.join(LAUNCHER_DIR, JAVA_COMPONENT, f"java{major}.json") + runtimes.write(runtimes_file) + + +if __name__ == "__main__": + main() diff --git a/meta/common/java.py b/meta/common/java.py index 8de3c47c4e..541d2fb374 100644 --- a/meta/common/java.py +++ b/meta/common/java.py @@ -7,4 +7,6 @@ ADOPTIUM_DIR = join(BASE_DIR, "adoptium") AZUL_DIR = join(BASE_DIR, "azul") ADOPTIUM_VERSIONS_DIR = join(ADOPTIUM_DIR, "versions") -AZUL_VERSIONS_DIR = join(AZUL_DIR, "versions")
\ No newline at end of file +AZUL_VERSIONS_DIR = join(AZUL_DIR, "versions") + +JAVA_COMPONENT = "net.minecraft.java"
\ No newline at end of file diff --git a/meta/model/enum.py b/meta/model/enum.py new file mode 100644 index 0000000000..08dda4bf4a --- /dev/null +++ b/meta/model/enum.py @@ -0,0 +1,32 @@ +import enum + + +class StrEnum(str, enum.Enum): + """ + StrEnum is a Python ``enum.Enum`` that inherits from ``str``. The default + ``auto()`` behavior uses the member name as its value. + + Example usage:: + + class Example(StrEnum): + UPPER_CASE = auto() + lower_case = auto() + MixedCase = auto() + + assert Example.UPPER_CASE == "UPPER_CASE" + assert Example.lower_case == "lower_case" + assert Example.MixedCase == "MixedCase" + """ + + def __new__(cls, value, *args, **kwargs): + if not isinstance(value, (str, enum.auto)): + raise TypeError( + f"Values of StrEnums must be strings: {value!r} is a {type(value)}" + ) + return super().__new__(cls, value, *args, **kwargs) + + def __str__(self): + return str(self.value) + + def _generate_next_value_(name, *_): + return name diff --git a/meta/model/java.py b/meta/model/java.py index d4d2e00cb9..a7907d90d2 100644 --- a/meta/model/java.py +++ b/meta/model/java.py @@ -3,7 +3,8 @@ from . import ( ) from pydantic import Field from datetime import datetime -from enum import Enum +from enum import IntEnum, Enum +from .enum import StrEnum from typing import Optional, List, Dict, Any, Iterator, Iterable, NamedTuple from collections import namedtuple from urllib.parse import urljoin, urlencode, urlparse, urlunparse @@ -11,6 +12,75 @@ from urllib.parse import urljoin, urlencode, urlparse, urlunparse # namedtuple to match the internal signature of urlunparse +class JavaRuntimeOS(StrEnum): + MacOsX64 = "mac-os-x64" + MacOsX86 = "mac-os-x86" # rare + MacOsArm64 = "mac-os-arm64" + # MacOsArm32 = "mac-os-arm32" # doesn't exsist + LinuxX64 = "linux-x64" + LinuxX86 = "linux-x86" + LinuxArm64 = "linux-arm64" + LinuxArm32 = "linux-arm32" + WindowsX64 = "windows-x64" + WindowsX86 = "windows-x86" + WindowsArm64 = "windows-arm64" + WindowsArm32 = "windows-arm32" + Unknown = "unknown" + + +class JavaRuntimeDownloadType(StrEnum): + Manifest = "manifest" + Archive = "archive" + + +class JavaVersionMeta(MetaBase): + major: int + minor: int + security: int + build: Optional[int] + + def __str__(self): + ver = f"{self.major}.{self.minor}.{self.security}" + if self.build is not None: + ver = f"{ver}+{self.build}" + return ver + + +class JavaChecksumType(StrEnum): + Sha1 = "sha1" + Sha256 = "sha256" + + +class JavaChecksumMeta(MetaBase): + type: JavaChecksumType + hash: str + + +class JavaRuntimeMeta(MetaBase): + name: str + vender: str + url: str + release_time: datetime = Field(alias="releaseTime") + checksum: Optional[JavaChecksumMeta] + recomended: bool + download_type: JavaRuntimeDownloadType = Field(alias="downloadType") + + +class JavaRuntimeMap(MetaBase): + __root__: dict[JavaRuntimeOS, list[JavaRuntimeMeta]] = { + os: [] for os in JavaRuntimeOS if os != JavaRuntimeOS.Unknown + } + + def __iter__(self) -> Iterator[JavaRuntimeOS]: + return iter(self.__root__) + + def __getitem__(self, item) -> list[JavaRuntimeMeta]: + return self.__root__[item] + + def __len__(self): + return len(self.__root__) + + class URLComponents(NamedTuple): scheme: str netloc: str @@ -21,7 +91,6 @@ class URLComponents(NamedTuple): class APIQuery(MetaBase): - def to_query(self): set_parts: dict[str, Any] = {} for key, value in self.dict().items(): @@ -38,15 +107,15 @@ class APIQuery(MetaBase): return urlencode(set_parts, doseq=True) -class AdoptiumJvmImpl(Enum): +class AdoptiumJvmImpl(StrEnum): Hostspot = "hotspot" -class AdoptiumVendor(Enum): +class AdoptiumVendor(StrEnum): Eclipse = "eclipse" -class AdoptiumArchitecture(Enum): +class AdoptiumArchitecture(StrEnum): X64 = "x64" X86 = "x86" X32 = "x32" @@ -59,22 +128,22 @@ class AdoptiumArchitecture(Enum): Riscv64 = "riscv64" -class AdoptiumReleaseType(Enum): +class AdoptiumReleaseType(StrEnum): GenralAccess = "ga" EarlyAccess = "ea" -class AdoptiumSortMethod(Enum): +class AdoptiumSortMethod(StrEnum): Default = "DEFAULT" Date = "DATE" -class AdoptiumSortOrder(Enum): +class AdoptiumSortOrder(StrEnum): Asc = "ASC" Desc = "DESC" -class AdoptiumImageType(Enum): +class AdoptiumImageType(StrEnum): Jdk = "jdk" Jre = "jre" Testimage = "testimage" @@ -84,12 +153,12 @@ class AdoptiumImageType(Enum): Sbom = "sbom" -class AdoptiumHeapSize(Enum): +class AdoptiumHeapSize(StrEnum): Normal = "normal" Large = "large" -class AdoptiumProject(Enum): +class AdoptiumProject(StrEnum): Jdk = "jdk" Valhalla = "valhalla" Metropolis = "metropolis" @@ -97,12 +166,12 @@ class AdoptiumProject(Enum): Shenandoah = "shenandoah" -class AdoptiumCLib(Enum): +class AdoptiumCLib(StrEnum): Musl = "musl" - Glibc = "Glibc" + Glibc = "glibc" -class AdoptiumOs(Enum): +class AdoptiumOs(StrEnum): Linux = "linux" Windows = "windows" Mac = "mac" @@ -128,20 +197,22 @@ class AdoptiumAPIFeatureReleasesQuery(APIQuery): page_size: int = 10 page: int = 0 project: Optional[AdoptiumProject] = AdoptiumProject.Jdk - sort_method: Optional[AdoptiumSortMethod] = AdoptiumSortMethod.Default - sort_order: Optional[AdoptiumSortOrder] = AdoptiumSortOrder.Desc - vender: Optional[AdoptiumVendor] = AdoptiumVendor.Eclipse + sort_method: Optional[AdoptiumSortMethod] = AdoptiumSortMethod.Default + sort_order: Optional[AdoptiumSortOrder] = AdoptiumSortOrder.Desc + vender: Optional[AdoptiumVendor] = AdoptiumVendor.Eclipse -def adoptiumAPIFeatureReleases( - feature: int, - release_type: AdoptiumReleaseType = AdoptiumReleaseType.GenralAccess, - query: AdoptiumAPIFeatureReleasesQuery = AdoptiumAPIFeatureReleasesQuery() +def adoptiumAPIFeatureReleasesUrl( + feature: int, + release_type: AdoptiumReleaseType = AdoptiumReleaseType.GenralAccess, + query: AdoptiumAPIFeatureReleasesQuery = AdoptiumAPIFeatureReleasesQuery(), ): - url = urlparse(ADOPTIUM_API_FEATURE_RELEASES.format( - feature_version=feature, - release_type=release_type.value, - )) + url = urlparse( + ADOPTIUM_API_FEATURE_RELEASES.format( + feature_version=feature, + release_type=release_type.value, + ) + ) return urlunparse(url._replace(query=query.to_query())) @@ -211,33 +282,42 @@ class AdoptiumRelease(MetaBase): release_notes: Optional[AdoptiumFile] -class AdoptiumReleasesWrap(MetaBase): - releases: list[AdoptiumRelease] +class AdoptiumReleases(MetaBase): + __root__: list[AdoptiumRelease] + def __iter__(self) -> Iterator[AdoptiumRelease]: + return iter(self.__root__) -class AzulProduct(Enum): + def __getitem__(self, item) -> AdoptiumRelease: + return self.__root__[item] + + def append(self, rls: AdoptiumRelease): + self.__root__.append(rls) + + +class AzulProduct(StrEnum): Zulu = "zulu" -class AzulAvailabilityType(Enum): +class AzulAvailabilityType(StrEnum): SA = "SA" CA = "CA" NV = "NV" _LA = "LA" -class AzulJavaPackageType(Enum): +class AzulJavaPackageType(StrEnum): Jdk = "jdk" Jre = "jre" -class AzulReleaseType(Enum): +class AzulReleaseType(StrEnum): CPU = "CPU" PSU = "PSU" LU = "LU" -class AzulOs(Enum): +class AzulOs(StrEnum): Linux = "linux" Macos = "macos" Qnx = "qnx" @@ -245,13 +325,13 @@ class AzulOs(Enum): Solaris = "solaris" -class AzulLibCType(Enum): +class AzulLibCType(StrEnum): Glibc = "glibc" Uclibc = "uclibc" Musl = "musl" -class AzulCPUGen(Enum): +class AzulCPUGen(StrEnum): V5 = "v5" V6kV6kz = "v6k_v6kz" V6t2 = "v6t2" @@ -259,7 +339,7 @@ class AzulCPUGen(Enum): V8 = "v8" -class AzulArch(Enum): +class AzulArch(StrEnum): Arm = "arm" X86 = "x86" Mips = "mips" @@ -268,19 +348,19 @@ class AzulArch(Enum): Sparc = "sparc" -class AzulHwBitness(Enum): +class AzulHwBitness(IntEnum): X32 = 32 X64 = 64 -class AzulAbi(Enum): +class AzulAbi(StrEnum): HardFloat = "hard_float" SoftFloat = "soft_float" Spe = "spe" Any = "any" -class AzulArchiveType(Enum): +class AzulArchiveType(StrEnum): Deb = "deb" Rpm = "rpm" Dmg = "dmg" @@ -290,30 +370,30 @@ class AzulArchiveType(Enum): Msi = "msi" -class AzulReleaseStatus(Enum): +class AzulReleaseStatus(StrEnum): Eval = "eval" Ea = "ea" Ga = "ga" Both = "both" -class AzulSupportTerm(Enum): +class AzulSupportTerm(StrEnum): Sts = "sts" Mts = "mts" Lts = "lts" -class AzulCertifications(Enum): +class AzulCertifications(StrEnum): Tck = "tck" _Aqavit = "aqavit" none = "none" -class AzulSignatureType(Enum): +class AzulSignatureType(StrEnum): Openpgp = "openpgp" -class AzulOsQueryParam(Enum): +class AzulOsQueryParam(StrEnum): Macos = "macos" Windows = "windows" Linux = "linux" @@ -323,7 +403,7 @@ class AzulOsQueryParam(Enum): Solaris = "solaris" -class AzulArchQueryParam(Enum): +class AzulArchQueryParam(StrEnum): X86 = "x86" X64 = "x64" Amd64 = "amd64" @@ -371,12 +451,12 @@ class AzulApiPackagesQuery(APIQuery): page_size: int = 100 -def azulApiPackages(query: AzulApiPackagesQuery = AzulApiPackagesQuery()): +def azulApiPackagesUrl(query: AzulApiPackagesQuery = AzulApiPackagesQuery()): url = urlparse(AZUL_API_PACKAGES) return urlunparse(url._replace(query=query.to_query())) -def azulApiPackageDetail(package_uuid: str): +def azulApiPackageDetailUrl(package_uuid: str): return AZUL_API_PACKAGE_DETAIL.format(package_uuid=package_uuid) @@ -431,9 +511,36 @@ class ZuluPackageList(MetaBase): availability_type: Optional[AzulAvailabilityType] -class ZuluPackagesListWrap(MetaBase): - packages: list[ZuluPackageList] +class ZuluPackages(MetaBase): + __root__: list[ZuluPackageList] + + def __iter__(self) -> Iterator[ZuluPackageList]: + return iter(self.__root__) + + def __getitem__(self, item) -> ZuluPackageList: + return self.__root__[item] + + def append(self, pkg: ZuluPackageList): + self.__root__.append(pkg) + + +class ZuluPackagesDetail(MetaBase): + __root__: list[ZuluPackageDetail] + + def __iter__(self) -> Iterator[ZuluPackageDetail]: + return iter(self.__root__) + + def __getitem__(self, item) -> ZuluPackageDetail: + return self.__root__[item] + + def append(self, pkg: ZuluPackageDetail): + self.__root__.append(pkg) + +MOJANG_OS_NAMES = ["mac-os", "linux", "windows"] -class ZuluPackagesDetailListWrap(MetaBase): - packages: list[ZuluPackageDetail] +MOJANG_OS_ARCHITECTURES = [ + "x64" "x86", + "arm64", + "arm32", +] diff --git a/meta/model/mojang.py b/meta/model/mojang.py index ce178efe2e..2e43899751 100644 --- a/meta/model/mojang.py +++ b/meta/model/mojang.py @@ -1,5 +1,6 @@ from datetime import datetime from typing import Optional, List, Dict, Any, Iterator +from .enum import StrEnum from pydantic import validator, Field @@ -185,51 +186,70 @@ class MojangLogging(MetaBase): type: str +class MojangJavaComponent(StrEnum): + JreLegacy = "jre-legacy" + Alpha = "java-runtime-alpha" + Beta = "java-runtime-beta" + Gamma = "java-runtime-gamma" + Exe = "minecraft-java-exe" + + class JavaVersion(MetaBase): - component: str = "jre-legacy" + component: MojangJavaComponent = MojangJavaComponent.JreLegacy major_version: int = Field(8, alias="majorVersion") -class JavaIndexAvailability(MetaBase): +class MojangJavaIndexAvailability(MetaBase): group: int progress: int -class JavaIndexManifest(MetaBase): +class MojangJavaIndexManifest(MetaBase): sha1: str size: int url: str -class JavaIndexVersion(MetaBase): +class MojangJavaIndexVersion(MetaBase): name: str released: datetime -class JavaRuntime(MetaBase): - availability: JavaIndexAvailability - manifest: JavaIndexManifest - version: JavaIndexVersion +class MojangJavaRuntime(MetaBase): + availability: MojangJavaIndexAvailability + manifest: MojangJavaIndexManifest + version: MojangJavaIndexVersion + +class MojangJavaIndexEntry(MetaBase): + __root__: dict[MojangJavaComponent, list[MojangJavaRuntime]] -class JavaIndexEntry(MetaBase): - java_runtime_alpha: list[JavaRuntime] = Field(alias="java-runtime-alpha") - java_runtime_beta: list[JavaRuntime] = Field(alias="java-runtime-beta") - java_runtime_gamma: list[JavaRuntime] = Field(alias="java-runtime-gamma") - jre_legacy: list[JavaRuntime] = Field(alias="jre-legacy") - minecraft_java_exe: list[JavaRuntime] = Field(alias="minecraft-java-exe") + def __iter__(self) -> Iterator[MojangJavaComponent]: + return iter(self.__root__) + + def __getitem__(self, item) -> list[MojangJavaRuntime]: + return self.__root__[item] + + +class MojangJavaOsName(StrEnum): + Gamecore = "gamecore" + Linux = "linux" + Linuxi386 = "linux-i386" + MacOs = "mac-os" + MacOSArm64 = "mac-os-arm64" + WindowsArm64 = "windows-arm64" + WindowsX64 = "windows-x64" + WindowsX86 = "windows-x86" class JavaIndex(MetaBase): - gamecore: JavaIndexEntry - linux: JavaIndexEntry - linux_i386: JavaIndexEntry = Field(alias="linux-i386") - mac_os: JavaIndexEntry = Field(alias="mac-os") - mac_os_arm64: JavaIndexEntry = Field(alias="mac-os-arm64") - windows_arm64: JavaIndexEntry = Field(alias="windows-arm64") - windows_x64: JavaIndexEntry = Field(alias="windows-x64") - windows_x86: JavaIndexEntry = Field(alias="windows-x86") + __root__: dict[MojangJavaOsName, MojangJavaIndexEntry] + def __iter__(self) -> Iterator[MojangJavaOsName]: + return iter(self.__root__) + + def __getitem__(self, item) -> MojangJavaIndexEntry: + return self.__root__[item] class MojangVersion(MetaBase): diff --git a/updateJava.py b/updateJava.py index 4eb6ffc486..ece97690be 100644 --- a/updateJava.py +++ b/updateJava.py @@ -12,23 +12,23 @@ from meta.common.java import ( ) from meta.model.java import ( ADOPTIUM_API_AVAILABLE_RELEASES, - adoptiumAPIFeatureReleases, + adoptiumAPIFeatureReleasesUrl, AdoptiumImageType, AdoptiumAPIFeatureReleasesQuery, AdoptiumAvailableReleases, AdoptiumRelease, - AdoptiumReleasesWrap, - azulApiPackages, + AdoptiumReleases, + azulApiPackagesUrl, AzulApiPackagesQuery, ZuluPackageList, - ZuluPackagesListWrap, + ZuluPackages, AzulArchiveType, AzulReleaseStatus, AzulAvailabilityType, AzulJavaPackageType, - azulApiPackageDetail, + azulApiPackageDetailUrl, ZuluPackageDetail, - ZuluPackagesDetailListWrap, + ZuluPackagesDetail, ) UPSTREAM_DIR = upstream_path() @@ -65,7 +65,7 @@ def main(): while True: query = AdoptiumAPIFeatureReleasesQuery( image_type=AdoptiumImageType.Jre, page_size=page_size, page=page) - api_call = adoptiumAPIFeatureReleases(feature, query=query) + api_call = adoptiumAPIFeatureReleasesUrl(feature, query=query) print("Fetching Page:", page, api_call) r_rls = sess.get(api_call) if r_rls.status_code == 404: @@ -81,9 +81,9 @@ def main(): page += 1 print("Total Adoptium releases for feature:", len(releases_for_feature)) - releases = AdoptiumReleasesWrap(releases=releases_for_feature) + releases = AdoptiumReleases(__root__=releases_for_feature) feature_file = os.path.join( - UPSTREAM_DIR, ADOPTIUM_VERSIONS_DIR, "{}.json".format(feature)) + UPSTREAM_DIR, ADOPTIUM_VERSIONS_DIR, f"java{feature}.json") releases.write(feature_file) print("Getting Azul Release Manifests") @@ -100,7 +100,7 @@ def main(): javafx_bundled=False, page=page, page_size=page_size) - api_call = azulApiPackages(query=query) + api_call = azulApiPackagesUrl(query=query) print("Processing Page:", page, api_call) @@ -117,38 +117,39 @@ def main(): page += 1 print("Total Azul Packages:", len(zulu_packages)) - packages = ZuluPackagesListWrap(packages=zulu_packages) + packages = ZuluPackages(__root__=zulu_packages) azul_manifest_file = os.path.join(UPSTREAM_DIR, AZUL_DIR, "packages.json") packages.write(azul_manifest_file) - azul_major_versions: dict[int, ZuluPackagesListWrap] = {} + azul_major_versions: dict[int, ZuluPackages] = {} - for pkg in packages.packages: + for pkg in packages: major_version = pkg.java_version[0] if major_version not in azul_major_versions: - azul_major_versions[major_version] = ZuluPackagesListWrap( - packages=[]) + azul_major_versions[major_version] = ZuluPackagesDetail(__root__=[]) - azul_major_versions[major_version].packages.append(pkg) + pkg_file = os.path.join( - UPSTREAM_DIR, AZUL_VERSIONS_DIR, "{}.json".format(pkg.package_uuid)) + UPSTREAM_DIR, AZUL_VERSIONS_DIR, f"{pkg.package_uuid}.json") if os.path.exists(pkg_file) and os.path.isfile(pkg_file): - pass + pkg_detail = ZuluPackageDetail.parse_file(pkg_file) + azul_major_versions[major_version].append(pkg_detail) else: - api_call = azulApiPackageDetail(pkg.package_uuid) + api_call = azulApiPackageDetailUrl(pkg.package_uuid) print("Fetching Azul package manifest:", pkg.package_uuid) r_pkg = sess.get(api_call) r_pkg.raise_for_status() pkg_detail = ZuluPackageDetail(**r_pkg.json()) pkg_detail.write(pkg_file) + azul_major_versions[major_version].append(pkg_detail) for major in azul_major_versions: major_file = os.path.join( - UPSTREAM_DIR, AZUL_VERSIONS_DIR, "{}.json".format(major)) + UPSTREAM_DIR, AZUL_VERSIONS_DIR, f"java{major}.json") azul_major_versions[major].write(major_file) diff --git a/updateMojang.py b/updateMojang.py index 91ca558cc9..03a77df19c 100755 --- a/updateMojang.py +++ b/updateMojang.py @@ -89,7 +89,7 @@ def update_javas(): r = sess.get(MOJANG_JAVA_URL) r.raise_for_status() - remote_javas = JavaIndex(**r.json()) + remote_javas = JavaIndex(__root__=r.json()) java_manifest_path = os.path.join(UPSTREAM_DIR, JAVA_MANIFEST_FILE) |