AstralTransRocketries/meta-unmojang
1
0
Fork 0
mirror of https://github.com/unmojang/meta.git synced 2025-09-23 11:10:53 -04:00
Code Issues Packages Projects Releases Wiki Activity

feat: generate java componate

Browse Source 
Signed-off-by: Rachel Powers <508861+Ryex@users.noreply.github.com>
This commit is contained in:
Rachel Powers 2023-05-10 20:55:45 -07:00
parent ac5171ea44
commit 651ff8356c
No known key found for this signature in database
GPG Key ID: E10E321EB160949B
7 changed files with 533 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

277
generateJava.py Normal file
View File

@ -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()

4
meta/common/java.py
View File

@ -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")
AZUL_VERSIONS_DIR = join(AZUL_DIR, "versions")
JAVA_COMPONENT = "net.minecraft.java"

32
meta/model/enum.py Normal file
View File

@ -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

207
meta/model/java.py
View File

@ -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__)
def __getitem__(self, item) -> AdoptiumRelease:
return self.__root__[item]
def append(self, rls: AdoptiumRelease):
self.__root__.append(rls)
class AzulProduct(Enum):
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 ZuluPackagesDetailListWrap(MetaBase):
packages: list[ZuluPackageDetail]
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"]
MOJANG_OS_ARCHITECTURES = [
"x64" "x86",
"arm64",
"arm32",
]

64
meta/model/mojang.py
View File

@ -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 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")
class MojangJavaIndexEntry(MetaBase):
__root__: dict[MojangJavaComponent, list[MojangJavaRuntime]]
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):

41
updateJava.py
View File

@ -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)

2
updateMojang.py
View File

@ -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)