packmodsdown 1.0.0__tar.gz

packmodsdown-1.0.0/LICENSE

@@ -0,0 +1,7 @@
+Copyright <2025> <QianFuv>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packmodsdown-1.0.0/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.3
+Name: packmodsdown
+Version: 1.0.0
+Summary: Batch download mods from CurseForge modpack zip files
+Author: QianFuv
+Author-email: QianFuv <qianfuv@qq.com>
+License: Copyright <2025> <QianFuv>
+         
+         Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+         
+         The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+         
+         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: rich>=13.0.0
+Requires-Dist: mypy>=1.18.2 ; extra == 'dev'
+Requires-Dist: ruff>=0.14.6 ; extra == 'dev'
+Requires-Python: >=3.12
+Provides-Extra: dev
+Description-Content-Type: text/markdown
+
+# PackModsDown
+
+Batch download mods from CurseForge modpack zip files.
+
+## Install
+
+```bash
+pip install packmodsdown
+```
+
+## Usage
+
+```bash
+pmd -m <modpack.zip> -o <output_dir> -k <api_key>
+```
+
+Or use the full name:
+
+```bash
+packmodsdown -m <modpack.zip> -o <output_dir> -k <api_key> [-c <concurrency>]
+```
+
+## Options
+
+| Flag                | Description              | Default  |
+| ------------------- | ------------------------ | -------- |
+| `-m, --modpack`     | Path to modpack `.zip`   | required |
+| `-o, --output`      | Output directory         | `./mods` |
+| `-k, --api-key`     | CurseForge API key       | required |
+| `-c, --concurrency` | Max concurrent downloads | `10`     |

packmodsdown-1.0.0/README.md

@@ -0,0 +1,30 @@
+# PackModsDown
+
+Batch download mods from CurseForge modpack zip files.
+
+## Install
+
+```bash
+pip install packmodsdown
+```
+
+## Usage
+
+```bash
+pmd -m <modpack.zip> -o <output_dir> -k <api_key>
+```
+
+Or use the full name:
+
+```bash
+packmodsdown -m <modpack.zip> -o <output_dir> -k <api_key> [-c <concurrency>]
+```
+
+## Options
+
+| Flag                | Description              | Default  |
+| ------------------- | ------------------------ | -------- |
+| `-m, --modpack`     | Path to modpack `.zip`   | required |
+| `-o, --output`      | Output directory         | `./mods` |
+| `-k, --api-key`     | CurseForge API key       | required |
+| `-c, --concurrency` | Max concurrent downloads | `10`     |

packmodsdown-1.0.0/pyproject.toml

@@ -0,0 +1,27 @@
+[project]
+name = "packmodsdown"
+version = "1.0.0"
+description = "Batch download mods from CurseForge modpack zip files"
+readme = "README.md"
+authors = [{ name = "QianFuv", email = "qianfuv@qq.com" }]
+license = { file = "LICENSE" }
+requires-python = ">=3.12"
+dependencies = ["httpx>=0.28.1", "rich>=13.0.0"]
+
+[project.scripts]
+packmodsdown = "packmodsdown.cli:main"
+pmd = "packmodsdown.cli:main"
+
+[project.optional-dependencies]
+dev = ["mypy>=1.18.2", "ruff>=0.14.6"]
+
+[build-system]
+requires = ["uv_build>=0.8.5,<0.9.0"]
+build-backend = "uv_build"
+
+
+[tool.ruff.lint]
+select = ["E", "F", "UP", "B", "SIM", "I"]
+
+[tool.mypy]
+disable_error_code = ["import-untyped"]

packmodsdown-1.0.0/src/packmodsdown/api.py

@@ -0,0 +1,146 @@
+"""
+Async CurseForge API client using httpx.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+BASE_URL = "https://api.curseforge.com"
+
+
+@dataclass(frozen=True)
+class FileInfo:
+    """
+    Metadata for a single mod file returned by the CurseForge API.
+
+    Args:
+        file_id: The file ID.
+        mod_id: The parent mod (project) ID.
+        display_name: Human-readable file display name.
+        file_name: Actual filename for download.
+        download_url: Direct download URL, may be None if restricted.
+    """
+
+    file_id: int
+    mod_id: int
+    display_name: str
+    file_name: str
+    download_url: str | None
+
+
+class CurseForgeClient:
+    """
+    Async HTTP client for the CurseForge API.
+
+    Args:
+        api_key: CurseForge API key for authentication.
+        timeout: Request timeout in seconds.
+    """
+
+    def __init__(self, api_key: str, timeout: float = 30.0) -> None:
+        self._client = httpx.AsyncClient(
+            base_url=BASE_URL,
+            headers={
+                "x-api-key": api_key,
+                "Accept": "application/json",
+                "Content-Type": "application/json",
+            },
+            timeout=timeout,
+        )
+
+    async def close(self) -> None:
+        """
+        Close the underlying HTTP client.
+        """
+        await self._client.aclose()
+
+    async def __aenter__(self) -> CurseForgeClient:
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self.close()
+
+    async def get_files(self, file_ids: list[int]) -> list[FileInfo]:
+        """
+        Batch-fetch file metadata via POST /v1/mods/files.
+
+        Args:
+            file_ids: List of CurseForge file IDs to look up.
+
+        Returns:
+            List of FileInfo objects with download metadata.
+
+        Raises:
+            httpx.HTTPStatusError: On non-2xx responses.
+        """
+        resp = await self._client.post(
+            "/v1/mods/files",
+            json={"fileIds": file_ids},
+        )
+        resp.raise_for_status()
+        data: list[dict[str, Any]] = resp.json().get("data", [])
+        return [_parse_file_info(item) for item in data]
+
+    async def get_mod_file_download_url(self, mod_id: int, file_id: int) -> str | None:
+        """
+        Fetch the download URL for a specific file as a fallback.
+
+        Uses GET /v1/mods/{modId}/files/{fileId}/download-url.
+
+        Args:
+            mod_id: The mod (project) ID.
+            file_id: The file ID.
+
+        Returns:
+            The download URL string, or None if unavailable.
+
+        Raises:
+            httpx.HTTPStatusError: On non-2xx responses.
+        """
+        resp = await self._client.get(f"/v1/mods/{mod_id}/files/{file_id}/download-url")
+        resp.raise_for_status()
+        return resp.json().get("data")
+
+    async def get_mod_file(self, mod_id: int, file_id: int) -> FileInfo:
+        """
+        Fetch metadata for a single mod file.
+
+        Uses GET /v1/mods/{modId}/files/{fileId}.
+
+        Args:
+            mod_id: The mod (project) ID.
+            file_id: The file ID.
+
+        Returns:
+            FileInfo object with download metadata.
+
+        Raises:
+            httpx.HTTPStatusError: On non-2xx responses.
+        """
+        resp = await self._client.get(f"/v1/mods/{mod_id}/files/{file_id}")
+        resp.raise_for_status()
+        data: dict[str, Any] = resp.json().get("data", {})
+        return _parse_file_info(data)
+
+
+def _parse_file_info(item: dict[str, Any]) -> FileInfo:
+    """
+    Parse a raw API file object into a FileInfo dataclass.
+
+    Args:
+        item: Raw JSON dict from the API response.
+
+    Returns:
+        Parsed FileInfo.
+    """
+    return FileInfo(
+        file_id=item.get("id", 0),
+        mod_id=item.get("modId", 0),
+        display_name=item.get("displayName", ""),
+        file_name=item.get("fileName", ""),
+        download_url=item.get("downloadUrl"),
+    )

packmodsdown-1.0.0/src/packmodsdown/cli.py

@@ -0,0 +1,70 @@
+"""
+CLI entry point for the CurseForge modpack mod downloader.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import sys
+
+from packmodsdown.downloader import download_modpack
+
+
+def main() -> None:
+    """
+    Parse command-line arguments and launch the modpack download process.
+    """
+    parser = argparse.ArgumentParser(
+        prog="pmd",
+        description="Download all mods from a CurseForge modpack zip file.",
+    )
+    parser.add_argument(
+        "-m",
+        "--modpack",
+        required=True,
+        help="Path to the CurseForge modpack .zip file.",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        default="./mods",
+        help="Output directory for downloaded mod files (default: ./mods).",
+    )
+    parser.add_argument(
+        "-k",
+        "--api-key",
+        required=True,
+        help="CurseForge API key for authentication.",
+    )
+    parser.add_argument(
+        "-c",
+        "--concurrency",
+        type=int,
+        default=10,
+        help="Maximum number of concurrent downloads (default: 10).",
+    )
+    args = parser.parse_args()
+
+    try:
+        asyncio.run(
+            download_modpack(
+                modpack_path=args.modpack,
+                output_dir=args.output,
+                api_key=args.api_key,
+                max_concurrency=args.concurrency,
+            )
+        )
+    except FileNotFoundError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        sys.exit(1)
+    except KeyError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        sys.exit(1)
+    except KeyboardInterrupt:
+        print("\nDownload cancelled by user.", file=sys.stderr)
+        sys.exit(130)
+
+
+if __name__ == "__main__":
+    main()

packmodsdown-1.0.0/src/packmodsdown/downloader.py

@@ -0,0 +1,287 @@
+"""
+Core download orchestration for CurseForge modpack mods.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import shutil
+import zipfile
+from pathlib import Path
+
+
+import httpx
+from rich.console import Console
+from rich.progress import (
+    BarColumn,
+    MofNCompleteColumn,
+    Progress,
+    SpinnerColumn,
+    TextColumn,
+    TimeRemainingColumn,
+)
+
+from packmodsdown.api import CurseForgeClient, FileInfo
+from packmodsdown.manifest import ModFileEntry, ModpackManifest, parse_manifest
+
+console = Console()
+
+
+async def download_modpack(
+    modpack_path: str | Path,
+    output_dir: str | Path,
+    api_key: str,
+    max_concurrency: int = 10,
+) -> None:
+    """
+    Parse a CurseForge modpack and download all mod files.
+
+    Args:
+        modpack_path: Path to the modpack .zip file.
+        output_dir: Directory to save downloaded mod files.
+        api_key: CurseForge API key.
+        max_concurrency: Maximum number of concurrent downloads.
+    """
+    manifest = parse_manifest(modpack_path)
+    _print_modpack_info(manifest)
+
+    output = Path(output_dir)
+    output.mkdir(parents=True, exist_ok=True)
+
+    async with CurseForgeClient(api_key) as client:
+        file_infos = await _resolve_file_infos(client, manifest)
+        await _download_all(client, file_infos, manifest.files, output, max_concurrency)
+
+    _extract_overrides_mods(modpack_path, manifest.overrides, output)
+
+
+def _extract_overrides_mods(
+    modpack_path: str | Path,
+    overrides_dir: str,
+    output: Path,
+) -> None:
+    """
+    Extract mod files from the overrides/mods directory in the modpack zip.
+
+    Args:
+        modpack_path: Path to the modpack .zip file.
+        overrides_dir: Name of the overrides directory in the manifest.
+        output: Output directory for mod files.
+    """
+    prefix = f"{overrides_dir}/mods/"
+    count = 0
+
+    with zipfile.ZipFile(modpack_path, "r") as zf:
+        for entry in zf.namelist():
+            if not entry.startswith(prefix):
+                continue
+            basename = entry.rsplit("/", 1)[-1]
+            if not basename:
+                continue
+            dest = output / basename
+            if dest.exists():
+                continue
+            with zf.open(entry) as src, open(dest, "wb") as dst:
+                shutil.copyfileobj(src, dst)
+            count += 1
+
+    if count:
+        console.print(f"[bold cyan]Overrides:[/] copied {count} files from {prefix}")
+
+
+def _print_modpack_info(manifest: ModpackManifest) -> None:
+    """
+    Display modpack metadata to the console.
+
+    Args:
+        manifest: Parsed modpack manifest.
+    """
+    console.print()
+    console.print(f"[bold cyan]Modpack:[/]  {manifest.name} v{manifest.version}")
+    console.print(f"[bold cyan]Author:[/]   {manifest.author}")
+    console.print(f"[bold cyan]MC:[/]       {manifest.minecraft_version}")
+    if manifest.mod_loaders:
+        console.print(f"[bold cyan]Loaders:[/]  {', '.join(manifest.mod_loaders)}")
+    console.print(f"[bold cyan]Mods:[/]     {len(manifest.files)} files to download")
+    console.print()
+
+
+async def _resolve_file_infos(
+    client: CurseForgeClient,
+    manifest: ModpackManifest,
+) -> dict[int, FileInfo]:
+    """
+    Batch-fetch file metadata from the CurseForge API.
+
+    Args:
+        client: Authenticated CurseForge API client.
+        manifest: Parsed modpack manifest with file entries.
+
+    Returns:
+        Dict mapping file_id to FileInfo.
+    """
+    file_ids = [f.file_id for f in manifest.files]
+
+    all_infos: list[FileInfo] = []
+    batch_size = 50
+    for i in range(0, len(file_ids), batch_size):
+        batch = file_ids[i : i + batch_size]
+        console.print(
+            f"[dim]Fetching file info batch "
+            f"{i // batch_size + 1}/{(len(file_ids) + batch_size - 1) // batch_size}"
+            f" ({len(batch)} files)...[/]"
+        )
+        try:
+            infos = await client.get_files(batch)
+            all_infos.extend(infos)
+        except httpx.HTTPStatusError as exc:
+            console.print(
+                f"[bold red]API error fetching batch: {exc.response.status_code}[/]"
+            )
+
+    return {info.file_id: info for info in all_infos}
+
+
+async def _download_all(
+    client: CurseForgeClient,
+    file_infos: dict[int, FileInfo],
+    entries: list[ModFileEntry],
+    output: Path,
+    max_concurrency: int,
+) -> None:
+    """
+    Download all mod files concurrently with progress tracking.
+
+    Args:
+        client: Authenticated CurseForge API client.
+        file_infos: Pre-fetched file metadata keyed by file_id.
+        entries: Original manifest file entries.
+        output: Output directory for downloads.
+        max_concurrency: Maximum concurrent downloads.
+    """
+    semaphore = asyncio.Semaphore(max_concurrency)
+    success = 0
+    failed = 0
+    skipped = 0
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        MofNCompleteColumn(),
+        TimeRemainingColumn(),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Downloading mods", total=len(entries))
+
+        async def _download_one(entry: ModFileEntry) -> None:
+            nonlocal success, failed, skipped
+
+            async with semaphore:
+                result = await _download_single_file(client, file_infos, entry, output)
+
+            if result == "success":
+                success += 1
+            elif result == "skipped":
+                skipped += 1
+            else:
+                failed += 1
+            progress.advance(task)
+
+        await asyncio.gather(*[_download_one(e) for e in entries])
+
+    console.print()
+    console.print(f"[bold green]Success:[/] {success}")
+    if skipped:
+        console.print(f"[bold yellow]Skipped:[/] {skipped}")
+    if failed:
+        console.print(f"[bold red]Failed:[/]  {failed}")
+    console.print()
+
+
+async def _download_single_file(
+    client: CurseForgeClient,
+    file_infos: dict[int, FileInfo],
+    entry: ModFileEntry,
+    output: Path,
+) -> str:
+    """
+    Download a single mod file.
+
+    Args:
+        client: Authenticated CurseForge API client.
+        file_infos: Pre-fetched file metadata.
+        entry: The manifest file entry to download.
+        output: Output directory.
+
+    Returns:
+        "success", "skipped", or "failed".
+    """
+    info = file_infos.get(entry.file_id)
+
+    if info is None:
+        try:
+            info = await client.get_mod_file(entry.project_id, entry.file_id)
+        except httpx.HTTPStatusError:
+            console.print(
+                f"[red]X Could not resolve file info: "
+                f"project={entry.project_id} file={entry.file_id}[/]"
+            )
+            return "failed"
+
+    file_name = info.file_name or f"{entry.project_id}_{entry.file_id}.jar"
+
+    if file_name.lower().endswith(".zip"):
+        return "skipped"
+
+    dest = output / file_name
+
+    if dest.exists():
+        return "skipped"
+
+    download_url = info.download_url
+    if not download_url:
+        try:
+            download_url = await client.get_mod_file_download_url(
+                entry.project_id, entry.file_id
+            )
+        except httpx.HTTPStatusError:
+            pass
+
+    if not download_url:
+        download_url = _construct_edge_url(entry.project_id, entry.file_id, file_name)
+
+    try:
+        async with httpx.AsyncClient(follow_redirects=True, timeout=60.0) as dl_client:
+            async with dl_client.stream("GET", download_url) as resp:
+                resp.raise_for_status()
+                with open(dest, "wb") as f:
+                    async for chunk in resp.aiter_bytes(chunk_size=65536):
+                        f.write(chunk)
+        return "success"
+    except (httpx.HTTPStatusError, httpx.RequestError) as exc:
+        console.print(f"[red]X Failed to download {file_name}: {exc}[/]")
+        if dest.exists():
+            dest.unlink()
+        return "failed"
+
+
+def _construct_edge_url(project_id: int, file_id: int, file_name: str) -> str:
+    """
+    Construct a CurseForge Edge CDN URL as a last-resort fallback.
+
+    The CDN URL pattern is:
+    https://edge.forgecdn.net/files/{first4}/{last3}/{fileName}
+
+    Args:
+        project_id: The mod project ID (unused but kept for consistency).
+        file_id: The file ID.
+        file_name: The filename.
+
+    Returns:
+        Constructed CDN URL string.
+    """
+    file_id_str = str(file_id)
+    first_part = file_id_str[:4]
+    second_part = file_id_str[4:]
+    return f"https://edge.forgecdn.net/files/{first_part}/{second_part}/{file_name}"

packmodsdown-1.0.0/src/packmodsdown/manifest.py

@@ -0,0 +1,147 @@
+"""
+Parse CurseForge modpack zip files and extract manifest information.
+"""
+
+from __future__ import annotations
+
+import json
+import zipfile
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class ModFileEntry:
+    """
+    Represents a single mod file entry from the manifest.
+
+    Args:
+        project_id: The CurseForge project (mod) ID.
+        file_id: The CurseForge file ID.
+        required: Whether this mod is required by the modpack.
+    """
+
+    project_id: int
+    file_id: int
+    required: bool = True
+
+
+@dataclass(frozen=True)
+class ModpackManifest:
+    """
+    Parsed CurseForge modpack manifest data.
+
+    Args:
+        name: Modpack display name.
+        version: Modpack version string.
+        author: Modpack author.
+        minecraft_version: Target Minecraft version.
+        mod_loaders: List of mod loader descriptors (e.g. forge-47.3.0).
+        files: List of mod file entries to download.
+        overrides: Name of the overrides directory inside the zip.
+    """
+
+    name: str
+    version: str
+    author: str
+    minecraft_version: str
+    mod_loaders: list[str] = field(default_factory=list)
+    files: list[ModFileEntry] = field(default_factory=list)
+    overrides: str = "overrides"
+
+
+def parse_manifest(modpack_path: str | Path) -> ModpackManifest:
+    """
+    Extract and parse manifest.json from a CurseForge modpack zip.
+
+    Args:
+        modpack_path: Path to the modpack .zip file.
+
+    Returns:
+        A ModpackManifest containing all parsed data.
+
+    Raises:
+        FileNotFoundError: If the modpack file does not exist.
+        KeyError: If manifest.json is not found inside the zip.
+        ValueError: If the manifest JSON is malformed.
+    """
+    modpack_path = Path(modpack_path)
+    if not modpack_path.exists():
+        raise FileNotFoundError(f"Modpack file not found: {modpack_path}")
+
+    with zipfile.ZipFile(modpack_path, "r") as zf:
+        manifest_name = _find_manifest(zf)
+        raw: dict[str, Any] = json.loads(zf.read(manifest_name))
+
+    return _build_manifest(raw)
+
+
+def _find_manifest(zf: zipfile.ZipFile) -> str:
+    """
+    Locate manifest.json inside the zip archive.
+
+    Args:
+        zf: An opened ZipFile object.
+
+    Returns:
+        The archive-internal path to manifest.json.
+
+    Raises:
+        KeyError: If no manifest.json is found.
+    """
+    for name in zf.namelist():
+        basename = name.rsplit("/", 1)[-1] if "/" in name else name
+        if basename.lower() == "manifest.json":
+            return name
+    raise KeyError("manifest.json not found in modpack archive")
+
+
+def _build_manifest(raw: dict[str, Any]) -> ModpackManifest:
+    """
+    Convert raw JSON dict into a ModpackManifest dataclass.
+
+    Args:
+        raw: Parsed JSON from manifest.json.
+
+    Returns:
+        A populated ModpackManifest.
+
+    Raises:
+        ValueError: If required fields are missing.
+    """
+    minecraft_block = raw.get("minecraft", {})
+    mc_version = minecraft_block.get("version", "unknown")
+
+    mod_loaders: list[str] = []
+    for loader in minecraft_block.get("modLoaders", []):
+        loader_id = loader.get("id", "")
+        if loader_id:
+            mod_loaders.append(loader_id)
+
+    files: list[ModFileEntry] = []
+    for entry in raw.get("files", []):
+        project_id = entry.get("projectID")
+        file_id = entry.get("fileID")
+        if project_id is None or file_id is None:
+            continue
+        files.append(
+            ModFileEntry(
+                project_id=int(project_id),
+                file_id=int(file_id),
+                required=bool(entry.get("required", True)),
+            )
+        )
+
+    if not files:
+        raise ValueError("Manifest contains no mod file entries")
+
+    return ModpackManifest(
+        name=raw.get("name", "Unknown Modpack"),
+        version=raw.get("version", "0.0.0"),
+        author=raw.get("author", "Unknown"),
+        minecraft_version=mc_version,
+        mod_loaders=mod_loaders,
+        files=files,
+        overrides=raw.get("overrides", "overrides"),
+    )