refactor: move liteloader to pydantic models

generateLiteloader.py

@@ -1,93 +1,108 @@
-from meta.liteloaderutil import *
+import os
+from datetime import datetime
+from typing import List, Tuple, Dict, Optional
+
 from meta.common import ensure_component_dir, polymc_path, upstream_path
+from meta.common.liteloader import LITELOADER_COMPONENT, VERSIONS_FILE
+from meta.common.mojang import MINECRAFT_COMPONENT
+from meta.model import MetaVersion, GradleSpecifier, Library, MetaPackage, Dependency
+from meta.model.liteloader import LiteloaderIndex, LiteloaderArtefact
 
 PMC_DIR = polymc_path()
 UPSTREAM_DIR = upstream_path()
 
-ensure_component_dir("com.mumfrey.liteloader")
+ensure_component_dir(LITELOADER_COMPONENT)
 
 
-# load the locally cached version list
+def process_artefacts(mc_version: str, artefacts: Dict[str, LiteloaderArtefact], is_snapshot: bool) \
-def loadLiteloaderJson():
+        -> Tuple[List[MetaVersion], Optional[MetaVersion]]:
-    with open(UPSTREAM_DIR + "/liteloader/versions.json", 'r', encoding='utf-8') as f:
+    versions: List[MetaVersion] = []
-        return LiteloaderIndex(json.load(f))
+    lookup: Dict[str, MetaVersion] = {}
-
+    latest_version = None
-
-remoteVersionlist = loadLiteloaderJson()
-
-
-def processArtefacts(mcVersion, liteloader, notSnapshots):
-    versions = []
-    lookup = {}
-    latestVersion = None
     latest = None
-    for id, artefact in liteloader.items():
+    for x, artefact in artefacts.items():
-        if id == 'latest':
+        if x == 'latest':
-            latestVersion = artefact.version
+            latest_version = artefact.version
             continue
-        version = PolyMCVersionFile(name="LiteLoader", uid="com.mumfrey.liteloader", version=artefact.version)
+        v = MetaVersion(
-        version.requires = [DependencyEntry(uid='net.minecraft', equals=mcVersion)]
+            name="LiteLoader",
-        version.releaseTime = datetime.datetime.utcfromtimestamp(int(artefact.timestamp))
+            uid=LITELOADER_COMPONENT,
-        version.addTweakers = [artefact.tweakClass]
+            version=artefact.version,
-        version.mainClass = "net.minecraft.launchwrapper.Launch"
+            requires=[Dependency(uid=MINECRAFT_COMPONENT, equals=mc_version)],
-        version.order = 10
+            release_time=datetime.utcfromtimestamp(int(artefact.timestamp)),
-        if notSnapshots:
+            additional_tweakers=[artefact.tweakClass],
-            version.type = "release"
+            main_class="net.minecraft.launchwrapper.Launch",
-        else:
+            order=10,
-            version.type = "snapshot"
+            libraries=artefact.libraries,
-        lookup[version.version] = version
+            type="release")
-        libraries = artefact.libraries
+
+        if is_snapshot:
+            v.type = "snapshot"
+
         # hack to make broken liteloader versions work
-        for lib in libraries:
+        for lib in v.libraries:
             if lib.name == GradleSpecifier("org.ow2.asm:asm-all:5.0.3"):
                 lib.url = "https://repo.maven.apache.org/maven2/"
             if lib.name == GradleSpecifier("org.ow2.asm:asm-all:5.2"):
                 lib.url = "http://repo.liteloader.com/"
-        liteloaderLib = PolyMCLibrary(
+
-            name=GradleSpecifier("com.mumfrey:liteloader:%s" % version.version),
+        liteloader_lib = Library(
+            name=GradleSpecifier("com.mumfrey:liteloader:%s" % v.version),
             url="http://dl.liteloader.com/versions/"
         )
-        if not notSnapshots:
+        if is_snapshot:
-            liteloaderLib.mmcHint = "always-stale"
+            liteloader_lib.mmcHint = "always-stale"
-        libraries.append(liteloaderLib)
+        v.libraries.append(liteloader_lib)
-        version.libraries = libraries
+
-        versions.append(version)
+        versions.append(v)
-    if latestVersion:
+        lookup[v.version] = v
-        latest = lookup[latestVersion]
+
+    if latest_version:
+        latest = lookup[latest_version]
     return versions, latest
 
 
-allVersions = []
+def process_versions(index: LiteloaderIndex) -> Tuple[List[MetaVersion], List[str]]:
-recommended = []
+    all_versions: List[MetaVersion] = []
-for mcVersion, versionObject in remoteVersionlist.versions.items():
+    recommended: List[str] = []
-    # ignore this for now. It should be a jar mod or something.
+    for mcVersion, versionObject in index.versions.items():
-    if mcVersion == "1.5.2":
+        # ignore this for now. It should be a jar mod or something.
-        continue
+        if mcVersion == "1.5.2":
-    latestSnapshot = None
+            continue
-    latestRelease = None
-    version = []
-    if versionObject.artefacts:
-        versions, latestRelease = processArtefacts(mcVersion, versionObject.artefacts.liteloader, True)
-        allVersions.extend(versions)
-    if versionObject.snapshots:
-        versions, latestSnapshot = processArtefacts(mcVersion, versionObject.snapshots.liteloader, False)
-        allVersions.extend(versions)
 
-    if latestRelease:
+        latest_release = None
-        recommended.append(latestRelease.version)
+        if versionObject.artefacts:
+            versions, latest_release = process_artefacts(mcVersion, versionObject.artefacts.liteloader, False)
+            all_versions.extend(versions)
+        if versionObject.snapshots:
+            versions, latest_snapshot = process_artefacts(mcVersion, versionObject.snapshots.liteloader, True)
+            all_versions.extend(versions)
 
-recommended.sort()
+        if latest_release:
+            recommended.append(latest_release.version)
 
-allVersions.sort(key=lambda x: x.releaseTime, reverse=True)
+    recommended.sort()
 
-for version in allVersions:
+    all_versions.sort(key=lambda x: x.release_time, reverse=True)
-    outFilepath = PMC_DIR + "/com.mumfrey.liteloader/%s.json" % version.version
+    return all_versions, recommended
-    with open(outFilepath, 'w') as outfile:
-        json.dump(version.to_json(), outfile, sort_keys=True, indent=4)
 
-sharedData = PolyMCSharedPackageData(uid='com.mumfrey.liteloader', name='LiteLoader')
+
-sharedData.recommended = recommended
+def main():
-sharedData.description = remoteVersionlist.meta.description
+    index = LiteloaderIndex.parse_file(os.path.join(UPSTREAM_DIR, VERSIONS_FILE))
-sharedData.projectUrl = remoteVersionlist.meta.url
+
-sharedData.authors = [remoteVersionlist.meta.authors]
+    all_versions, recommended = process_versions(index)
-sharedData.write()
+
+    for version in all_versions:
+        version.write(os.path.join(PMC_DIR, LITELOADER_COMPONENT, f"{version.version}.json"))
+
+    package = MetaPackage(uid=LITELOADER_COMPONENT,
+                          name='LiteLoader',
+                          description=index.meta.description,
+                          project_url=index.meta.url,
+                          authors=[index.meta.authors],
+                          recommended=recommended)
+    package.write(os.path.join(PMC_DIR, LITELOADER_COMPONENT, "package.json"))
+
+
+if __name__ == '__main__':
+    main()

meta/common/liteloader.py

@@ -0,0 +1,7 @@
+from os.path import join
+
+BASE_DIR = "liteloader"
+
+VERSIONS_FILE = join(BASE_DIR, "versions.json")
+
+LITELOADER_COMPONENT = "com.mumfrey.liteloader"

meta/liteloaderutil.py

@@ -1,118 +0,0 @@
-from .metautil import *
-
-'''
-    "repo":{
-        "stream":"RELEASE",
-        "type":"m2",
-        "url":"http:\/\/dl.liteloader.com\/repo\/",
-        "classifier":""
-    },
-'''
-
-
-class LiteloaderRepo(JsonObject):
-    stream = StringProperty(required=True)
-    type = StringProperty(required=True)
-    url = StringProperty(required=True)
-    classifier = StringProperty(required=True)
-
-
-'''
-    "53639d52340479ccf206a04f5e16606f":{
-        "tweakClass":"com.mumfrey.liteloader.launch.LiteLoaderTweaker",
-        "libraries":[
-            {
-                "name":"net.minecraft:launchwrapper:1.5"
-            },
-            {
-                "name":"net.sf.jopt-simple:jopt-simple:4.5"
-            },
-            {
-                "name":"org.ow2.asm:asm-all:4.1"
-            }
-        ],
-        "stream":"RELEASE",
-        "file":"liteloader-1.5.2_01.jar",
-        "version":"1.5.2_01",
-        "md5":"53639d52340479ccf206a04f5e16606f",
-        "timestamp":"1367366420"
-    },
-'''
-
-
-class LiteloaderArtefact(JsonObject):
-    tweakClass = StringProperty(required=True)
-    libraries = ListProperty(PolyMCLibrary, required=True)
-    stream = StringProperty(required=True)
-    file = StringProperty(required=True)
-    version = StringProperty(required=True)
-    build = StringProperty(default=None, exclude_if_none=True)
-    md5 = StringProperty(required=True)
-    timestamp = StringProperty(required=True)
-    srcJar = StringProperty(default=None, exclude_if_none=True)
-    mcpJar = StringProperty(default=None, exclude_if_none=True)
-
-
-class LiteloaderDev(JsonObject):
-    fgVersion = StringProperty(default=None, exclude_if_none=True)
-    mappings = StringProperty(required=None, exclude_if_none=True)
-    mcp = StringProperty(default=None, exclude_if_none=True)
-
-
-class LiteloaderArtefacts(JsonObject):
-    liteloader = DictProperty(LiteloaderArtefact, name="com.mumfrey:liteloader", required=True)
-
-
-class LiteloaderSnapshot(LiteloaderArtefact):
-    lastSuccessfulBuild = IntegerProperty()
-
-
-class LiteloaderSnapshots(JsonObject):
-    libraries = ListProperty(PolyMCLibrary, required=True)
-    liteloader = DictProperty(LiteloaderSnapshot, name="com.mumfrey:liteloader", required=True)
-
-
-'''
-    "1.10.2":{
-        "dev": { ... },
-        "repo":{ ... },
-        "artefacts":{
-            "com.mumfrey:liteloader":{ },
-            ...
-        },
-        "snapshots":{
-            ...
-        }
-'''
-
-
-class LiteloaderEntry(JsonObject):
-    dev = ObjectProperty(LiteloaderDev, default=None, exclude_if_none=True)
-    repo = ObjectProperty(LiteloaderRepo, required=True)
-    artefacts = ObjectProperty(LiteloaderArtefacts, default=None, exclude_if_none=True)
-    snapshots = ObjectProperty(LiteloaderSnapshots, default=None, exclude_if_none=True)
-
-
-'''
-    "meta":{
-        "description":"LiteLoader is a lightweight mod bootstrap designed to provide basic loader functionality for mods which don't need to modify game mechanics.",
-        "authors":"Mumfrey",
-        "url":"http:\/\/dl.liteloader.com",
-        "updated":"2017-02-22T11:34:07+00:00",
-        "updatedTime":1487763247
-    },
-'''
-
-
-class LiteloaderMeta(JsonObject):
-    description = StringProperty(required=True)
-    authors = StringProperty(required=True)
-    url = StringProperty(required=True)
-    updated = ISOTimestampProperty(required=True)
-    updatedTime = IntegerProperty(required=True)
-
-
-# The raw Forge version index
-class LiteloaderIndex(JsonObject):
-    meta = ObjectProperty(LiteloaderMeta, required=True)
-    versions = DictProperty(LiteloaderEntry)

meta/model/liteloader.py

@@ -0,0 +1,108 @@
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+
+from pydantic import Field
+
+from . import Library, MetaBase
+
+
+class LiteloaderDev(MetaBase):
+    fgVersion: Optional[str]
+    mappings: Optional[str]
+    mcp: Optional[str]
+
+
+class LiteloaderRepo(MetaBase):
+    """
+        "repo":{
+            "stream":"RELEASE",
+            "type":"m2",
+            "url":"http://dl.liteloader.com/repo/",
+            "classifier":""
+        },
+    """
+    stream: str
+    type: str
+    url: str
+    classifier: str
+
+
+class LiteloaderArtefact(MetaBase):
+    """
+        "53639d52340479ccf206a04f5e16606f":{
+            "tweakClass":"com.mumfrey.liteloader.launch.LiteLoaderTweaker",
+            "libraries":[
+                {
+                    "name":"net.minecraft:launchwrapper:1.5"
+                },
+                {
+                    "name":"net.sf.jopt-simple:jopt-simple:4.5"
+                },
+                {
+                    "name":"org.ow2.asm:asm-all:4.1"
+                }
+            ],
+            "stream":"RELEASE",
+            "file":"liteloader-1.5.2_01.jar",
+            "version":"1.5.2_01",
+            "md5":"53639d52340479ccf206a04f5e16606f",
+            "timestamp":"1367366420"
+        },
+    """
+    tweakClass: str
+    libraries: List[Library]
+    stream: str
+    file: str
+    version: str
+    build: Optional[str]
+    md5: str
+    timestamp: str
+    srcJar: Optional[str]
+    mcpJar: Optional[str]
+    lastSuccessfulBuild: Optional[int]  # only for snapshots
+
+
+class LiteloaderArtefacts(MetaBase):
+    liteloader: Dict[str, LiteloaderArtefact] = Field(alias="com.mumfrey:liteloader")
+    libraries: Optional[List[Library]]
+
+
+class LiteloaderEntry(MetaBase):
+    """
+        "1.10.2":{
+            "dev": { ... },
+            "repo":{ ... },
+            "artefacts":{
+                "com.mumfrey:liteloader":{ },
+                ...
+            },
+            "snapshots":{
+                ...
+            }
+    """
+    dev: Optional[LiteloaderDev]
+    repo: LiteloaderRepo
+    artefacts: Optional[LiteloaderArtefacts]
+    snapshots: Optional[LiteloaderArtefacts]
+
+
+class LiteloaderMeta(MetaBase):
+    """
+        "meta":{
+            "description":"LiteLoader is a lightweight mod bootstrap designed to provide basic loader functionality for mods which don't need to modify game mechanics.",
+            "authors":"Mumfrey",
+            "url":"http://dl.liteloader.com",
+            "updated":"2017-02-22T11:34:07+00:00",
+            "updatedTime":1487763247
+        },
+    """
+    description: str
+    authors: str
+    url: str
+    updated: datetime
+    updated_time: int = Field(alias="updatedTime")
+
+
+class LiteloaderIndex(MetaBase):
+    meta: LiteloaderMeta
+    versions: Dict[Any, LiteloaderEntry]

updateLiteloader.py

@@ -1,37 +1,40 @@
-'''
+import json
- Get the source files necessary for generating Forge versions
+import os
-'''
-import copy
-import sys
 
 import requests
 from cachecontrol import CacheControl
 from cachecontrol.caches import FileCache
-from meta.liteloaderutil import *
 
-UPSTREAM_DIR = os.environ["UPSTREAM_DIR"]
+from meta.common import upstream_path
-
+from meta.common.liteloader import VERSIONS_FILE
-
+from meta.model.liteloader import LiteloaderIndex
-def eprint(*args, **kwargs):
-    print(*args, file=sys.stderr, **kwargs)
 
+UPSTREAM_DIR = upstream_path()
 
 forever_cache = FileCache('caches/http_cache', forever=True)
 sess = CacheControl(requests.Session(), forever_cache)
 
-# get the remote version list
-r = sess.get('http://dl.liteloader.com/versions/versions.json')
-r.raise_for_status()
 
-# make sure it's JSON
+def main():
-main_json = r.json()
+    # get the remote version list
+    r = sess.get('http://dl.liteloader.com/versions/versions.json')
+    r.raise_for_status()
 
-# make sure we understand the schema
+    # make sure it's JSON
-remoteVersionlist = LiteloaderIndex(copy.deepcopy(main_json))
+    main_json = r.json()
-newStr = json.dumps(remoteVersionlist.to_json(), sort_keys=True)
-origStr = json.dumps(main_json, sort_keys=True)
-assert newStr == origStr
 
-# save the json it to file
+    # make sure we understand the schema
-with open(UPSTREAM_DIR + "/liteloader/versions.json", 'w', encoding='utf-8') as f:
+    remote_versions = LiteloaderIndex.parse_obj(main_json)
-    json.dump(main_json, f, sort_keys=True, indent=4)
+    parsed = remote_versions.json()
+    original = json.dumps(main_json, sort_keys=True, indent=4)
+    assert parsed == original
+
+    print("Successfully parsed index")
+    print(f"Last updated {remote_versions.meta.updated}")
+
+    # save the json it to file
+    remote_versions.write(os.path.join(UPSTREAM_DIR, VERSIONS_FILE))
+
+
+if __name__ == '__main__':
+    main()