cursefetch 0.1.0__py3-none-any.whl

cursefetch/__init__.py

@@ -0,0 +1,170 @@
+import argparse
+import json
+import os
+import traceback
+
+import cursefetch.cursefetch as cf
+
+from . import download
+
+
+def main() -> None:
+    print("Hello from CurseFetch!")
+
+    argparser = argparse.ArgumentParser(
+        description="Fetch the latest version of a CurseForge project."
+    )
+    argparser.add_argument("project_id", help="The ID of the CurseForge project.")
+    subparsers = argparser.add_subparsers(dest="command")
+
+    # list versions
+    list_parser = subparsers.add_parser(
+        "list-version", help="List the versions of the project."
+    )
+    list_parser.add_argument(
+        "-d",
+        "--details",
+        help="Show detailed information about each version (in JSON format).",
+        action="store_true",
+    )
+
+    # download version
+    download_parser = subparsers.add_parser(
+        "download", help="Download a specific version of the project."
+    )
+    download_parser.add_argument(
+        "version",
+        help="The version name or id to download (default: latest).",
+        default="latest",
+    )
+    download_parser.add_argument("--simulate-version-selection", action="store_true")
+    download_parser.add_argument(
+        "-t",
+        "--release-type",
+        help="The release type to filter by. (default: none). (only applicable when version is 'latest')",
+        choices=["release", "beta", "alpha"],
+        default=None,
+    )
+    download_parser.add_argument(
+        "--version-order",
+        help="The method to order versions by when selecting the latest version. (default: default)",
+        choices=["default", "semver"],
+        default="default",
+    )
+    download_parser.add_argument(
+        "-o", "--output", help="The path of the output file/directory."
+    )
+    download_parser.add_argument(
+        "-u",
+        "--uncompress",
+        help="Uncompress the downloaded file to the output directory.",
+        action="store_true",
+    )
+
+    args = argparser.parse_args()
+    if args.command == "list-version":
+        command_list_version(args)
+    elif args.command == "download":
+        command_download(args)
+    else:
+        argparser.print_help()
+
+
+def command_list_version(args):
+    try:
+        list = cf.get_version_list(args.project_id)
+        if args.details:
+            print(json.dumps(list, indent=2))
+        else:
+            print_version_list_simple(list)
+    except Exception as e:
+        print("Failed to fetch version list.")
+        print(e)
+
+
+def print_version_list_simple(version_list: list) -> None:
+    # calculate the maximum length of the id, name, and release type fields for formatting
+    id_max_length = max(len(str(v["id"])) for v in version_list)
+    name_max_length = max(len(v["displayName"]) for v in version_list)
+    file_date_max_length = max(len(str(v["fileDate"])) for v in version_list)
+
+    def release_type_to_str(
+        release_type: int | str, dict={1: "release", 2: "beta", 3: "alpha"}
+    ) -> str:
+        if isinstance(release_type, int):
+            return dict.get(release_type, "unknown")
+        return release_type
+
+    for v in version_list:
+        id = str(v["id"]).rjust(id_max_length)
+        name = str(v["displayName"]).ljust(name_max_length)
+        release_type = release_type_to_str(v["releaseType"])
+        # the length of "release" and "unknown" is 7
+        release_type = release_type.rjust(7)
+        file_date = str(v["fileDate"]).ljust(file_date_max_length)
+        print(f"({id})  {name}  {release_type}  {file_date}")
+
+
+def command_download(args):
+    try:
+        version = args.version
+        # the selected version info dict
+        version_info = None
+
+        # grab the version list
+        list = None
+        try:
+            list = cf.get_version_list(args.project_id)
+        except:
+            print("Failed to fetch version list.")
+            raise
+
+        if version == "latest":
+            # handle latest version selection
+            try:
+                version_info = cf.select_latest_version(
+                    list, release_type=args.release_type, order_by=args.version_order
+                )
+            except:
+                print("Failed to select the latest version.")
+                raise
+        else:
+            # or find the version by name or id
+            for v in list:
+                if v["displayName"] == version or str(v["id"]) == version:
+                    version_info = v
+                    break
+
+        # fast fail if we couldn't find the version
+        if version_info is None:
+            raise ValueError("Unable to find the specified version.")
+
+        # dump simulation info and return
+        if args.simulate_version_selection:
+            print("Selected version")
+            print_version_list_simple([version_info])
+            return
+
+        # show the selected version info
+        print(f"Version: {version_info['displayName']} (id: {version_info['id']})")
+
+        # download the file
+        output_path = args.output if not args.uncompress else "temp_download.zip"
+        try:
+            download.download_url(version_info["downloadUrl"], output_path)
+        except:
+            print("Failed to download the version.")
+            raise
+
+        # uncompress the file if requested
+        if args.uncompress:
+            print("Uncompressing the downloaded file")
+            try:
+                download.uncompress_zip(output_path, args.output)
+            except:
+                print("Failed to uncompress the downloaded file.")
+                raise
+
+    except Exception as e:
+        print("Failed to download the version.")
+        traceback.print_exception(e)

cursefetch/cursefetch.py

@@ -0,0 +1,82 @@
+import os
+from typing import Literal
+
+import requests
+
+
+def get_version_list(project_id: str) -> list:
+    """
+    Fetches the list of all versions for a given CurseForge project ID.
+    :param project_id: The ID of the CurseForge project to fetch versions for.
+    :return: A list of version information.
+    """
+    PER_REQUEST_COUNT = 50
+    url = f"https://api.curseforge.com/v1/mods/{project_id}/files?pageSize={PER_REQUEST_COUNT}"
+
+    api_key = os.getenv("CF_API_KEY")
+    if api_key is None:
+        raise ValueError("CF_API_KEY environment variable is not set.")
+
+    all = []
+    try:
+        resp = requests.get(url, headers={"X-API-KEY": api_key})
+        resp.raise_for_status()
+        data = resp.json()
+        if "data" in data and len(data["data"]) > 0:
+            all.extend(data["data"])
+        else:
+            raise ValueError("Unable to find any files for the given project ID.")
+        while "pagination" in data and len(all) < data["pagination"]["totalCount"]:
+            # fetch all pages until we have all the data
+            resp = requests.get(
+                f"{url}&index={data['pagination']['index'] + PER_REQUEST_COUNT}",
+                headers={"X-API-KEY": api_key},
+            )
+            resp.raise_for_status()
+            data = resp.json()
+            all.extend(data["data"])
+        return all
+    except requests.RequestException as e:
+        print(f"Error fetching data from CurseForge API: {e}")
+        raise
+    except (KeyError, IndexError) as e:
+        print(f"Error parsing data from CurseForge API: {e}")
+        raise
+
+
+def select_latest_version(
+    version_list: list,
+    release_type: Literal["release", "beta", "alpha", 1, 2, 3] | None = None,
+    order_by: Literal["default", "semver"] = "default",
+) -> dict:
+    """
+    Select the latest version from a list of versions, optionally filtering by release type and ordering by semver.
+    :param version_list: The list of versions to select from.
+    :param release_type: The release type to filter by (release, beta, alpha, or their corresponding integers).
+    :param order_by: The method to order versions by (default or semver).
+    :return: The latest version information.
+    """
+
+    # convert releaseType to int if it's a string
+    if isinstance(release_type, str):
+        release_type = {"release": 1, "beta": 2, "alpha": 3}[release_type]
+    release_type: int  # hint type
+
+    # filter the list by releaseType if it's not None
+    if release_type is not None:
+        version_list = [v for v in version_list if v["releaseType"] == release_type]
+        if len(version_list) == 0:
+            raise ValueError("No versions found for the given release type.")
+
+    if order_by == "semver":
+        from packaging.version import InvalidVersion, Version
+
+        try:
+            return max(version_list, key=lambda v: Version(v["displayName"]))
+        except InvalidVersion:
+            # there's a version that doesn't follow semver, so we can't sort by semver
+            # FIXME: However, we used a package that may not fully support semver, so find a workaround when someone needs.
+            raise
+    else:
+        # curseforge responds with a upload-order sorted list, so the first item is the latest version
+        return version_list[0]

cursefetch/download.py

@@ -0,0 +1,35 @@
+import os
+import zipfile
+
+import requests
+from tqdm import tqdm
+
+
+def download_url(url: str, destination: str):
+    with requests.get(url, stream=True) as r:
+        r.raise_for_status()
+        total_size = int(r.headers.get("Content-Length", 0))
+        with (
+            open(destination, "wb") as f,
+            # use tqdm to show a progress bar while downloading
+            tqdm(
+                desc=destination,
+                total=total_size,
+                unit="iB",
+                unit_scale=True,
+                unit_divisor=1024,
+            ) as bar,
+        ):
+            for chunk in r.iter_content(chunk_size=8192):
+                if chunk:  # filter out keep-alive new chunks
+                    size = f.write(chunk)
+                    bar.update(size)
+
+
+def uncompress_zip(zip_path: str, destination: str):
+    # ensure the destination directory exists
+    if not os.path.exists(destination):
+        os.makedirs(destination)
+
+    with zipfile.ZipFile(zip_path, "r") as zip:
+        zip.extractall(destination)

cursefetch-0.1.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: cursefetch
+Version: 0.1.0
+Summary: Add your description here
+Author-email: Taskeren <r0yalist@outlook.com>
+Requires-Python: >=3.10
+Requires-Dist: packaging>=26.0
+Requires-Dist: requests>=2.33.0
+Requires-Dist: tqdm>=4.67.3

cursefetch-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+cursefetch/__init__.py,sha256=pjykjIv3-Ah7aikv1q01Zi_HsoOLtU4IoyHTOLH4RJw,5613
+cursefetch/cursefetch.py,sha256=87voT_6iFIfTtC_F50AyutStw2oVEp1su_3DEVQn-Ws,3361
+cursefetch/download.py,sha256=TNx83hNDBmfoPHYXTQPaMjMcFbNOK3y9G9vWuVGW_t0,1076
+cursefetch-0.1.0.dist-info/METADATA,sha256=M3-zdfiSBjblrN5FjLyXVbBdIBEM2aP7XGKl_g7W4gw,250
+cursefetch-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+cursefetch-0.1.0.dist-info/entry_points.txt,sha256=3RXhRth86L5eawsTBcu1eilBxVeinMqs_p-fzM_JdIE,47
+cursefetch-0.1.0.dist-info/RECORD,,

cursefetch-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

cursefetch-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cursefetch = cursefetch:main