modrinth4py 0.0.1__py3-none-any.whl

modrinth4py/__init__.py

@@ -0,0 +1,39 @@
+from modrinth4py.client import ModrinthClient
+from modrinth4py.exceptions import ModrinthAPIError
+from modrinth4py.types import (
+    DictKV,
+    ListDictKV,
+    SideSupport,
+    ProjectStatus,
+    RequestedStatus,
+    ProjectType,
+    VersionType,
+    VersionStatus,
+    RequestedVersionStatus,
+    DonationUrl,
+    NewVersion,
+    NewProject,
+    ProjectUpdate,
+    VersionUpdate,
+    GalleryImage,
+)
+
+__all__ = [
+    "ModrinthClient",
+    "ModrinthAPIError",
+    "DictKV",
+    "ListDictKV",
+    "SideSupport",
+    "ProjectStatus",
+    "RequestedStatus",
+    "ProjectType",
+    "VersionType",
+    "VersionStatus",
+    "RequestedVersionStatus",
+    "DonationUrl",
+    "NewVersion",
+    "NewProject",
+    "ProjectUpdate",
+    "VersionUpdate",
+    "GalleryImage",
+]

modrinth4py/client.py

@@ -0,0 +1,311 @@
+from __future__ import annotations
+
+import json
+import logging
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from contextlib import ExitStack
+from pathlib import Path
+from typing import Optional, List, Any, IO, Iterator, Callable, Dict
+
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3 import Retry
+from importlib.metadata import version, PackageNotFoundError
+
+from modrinth4py.exceptions import ModrinthAPIError
+from modrinth4py.types import (
+    DictKV,
+    ListDictKV,
+    NewProject,
+    NewVersion,
+    GalleryImage,
+    ProjectUpdate,
+    VersionUpdate,
+)
+
+logger = logging.getLogger(__name__)
+
+try:
+    __version__ = version("modrinth4py")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+def _cut_game_versions_until(cutoff_version: str, versions: List[DictKV]) -> List[DictKV]:
+    result: List[DictKV] = []
+    for version in versions:
+        result.append(version)
+        if version.get("version") == cutoff_version:
+            break
+    return result
+
+
+class ModrinthClient:
+    """
+    HTTP client for the Modrinth API.
+
+    Rate limiting is handled automatically. Requests are retried on 429/5xx responses.
+    For concurrent workloads, use :meth:`parallel_requests`.
+
+    :param token: Modrinth API token (PAT).
+    :param api_url: Base URL for the API. Defaults to ``https://api.modrinth.com``.
+    :param user_agent: Value sent as the ``User-Agent`` header.
+    :param debug: Enable debug-level request/response logging via stdlib ``logging``.
+    :param verbose_debug: Also log full request bodies (implies ``debug=True``).
+    """
+
+    DEFAULT_API_URL = "https://api.modrinth.com"
+
+    def __init__(
+        self,
+        token: str,
+        api_url: str = DEFAULT_API_URL,
+        user_agent: str = f"modrinth4py/{__version__}",
+        debug: bool = False,
+        verbose_debug: bool = False,
+    ) -> None:
+        self.api_url = api_url
+        self._debug = debug or verbose_debug
+        self._verbose_debug = verbose_debug
+
+        self._session = requests.Session()
+        self._session.headers.update({"Authorization": token, "User-Agent": user_agent})
+
+        self._ratelimit_lock = threading.Lock()
+        self._ratelimit_limit = 300
+        self._ratelimit_remaining = 300
+        self._ratelimit_reset = 0
+
+    def _make_thread_session(self) -> requests.Session:
+        s = requests.Session()
+        s.headers.update(self._session.headers)
+        s.headers["Connection"] = "close"
+
+        retry = Retry(
+            total=10,
+            backoff_factor=0.3,
+            status_forcelist=[429, 500, 502, 503, 504],
+        )
+        adapter = HTTPAdapter(max_retries=retry, pool_connections=1, pool_maxsize=1)
+        s.mount("https://", adapter)
+        return s
+
+    def _update_ratelimit(self, response: requests.Response) -> None:
+        with self._ratelimit_lock:
+            try:
+                self._ratelimit_limit = int(response.headers.get("X-Ratelimit-Limit", self._ratelimit_limit))
+                self._ratelimit_remaining = int(response.headers.get("X-Ratelimit-Remaining", self._ratelimit_remaining))
+                self._ratelimit_reset = int(response.headers.get("X-Ratelimit-Reset", 0))
+            except (ValueError, TypeError):
+                pass
+
+            if self._debug:
+                logger.debug(
+                    "rate limit updated: limit=%d remaining=%d reset=%d",
+                    self._ratelimit_limit,
+                    self._ratelimit_remaining,
+                    self._ratelimit_reset,
+                )
+
+    def _respect_ratelimit(self) -> None:
+        with self._ratelimit_lock:
+            if self._ratelimit_remaining > 0:
+                return
+
+            sleep_time = self._ratelimit_reset
+            logger.warning("rate limited - sleeping %d seconds", sleep_time)
+            self._ratelimit_remaining = self._ratelimit_limit
+            self._ratelimit_reset = 0
+
+        if sleep_time > 0:
+            time.sleep(sleep_time)
+
+    def _log_request(self, prepped: requests.PreparedRequest) -> None:
+        logger.debug("%s %s", prepped.method, prepped.url)
+        for k, v in prepped.headers.items():
+            if k.lower() == "authorization":
+                v = f"{v[:10]}..." if len(v) > 10 else "***"
+            logger.debug("  %s: %s", k, v)
+
+        if prepped.body is None:
+            logger.debug("  body: (none)")
+        elif "json" in prepped.headers.get("Content-Type", "").lower() and isinstance(prepped.body, bytes):
+            try:
+                logger.debug("  body: %s", json.dumps(json.loads(prepped.body.decode()), indent=2))
+            except Exception:
+                logger.debug("  body (raw): %r", prepped.body)
+        elif isinstance(prepped.body, (str, bytes)):
+            preview = prepped.body[:200] if isinstance(prepped.body, str) else prepped.body[:200].decode(errors="replace")
+            logger.debug("  body: %s", preview)
+        else:
+            logger.debug("  body: <binary/multipart>")
+
+    def _request(self, method: str, endpoint: str, api_version: int = 2, **kwargs) -> Any:
+        url = f"{self.api_url}/v{api_version}{endpoint}"
+
+        thread = threading.current_thread()
+        session: Optional[requests.Session] = getattr(thread, "_modrinth4py_session", None)
+        if session is None:
+            session = self._make_thread_session()
+            setattr(thread, "_modrinth4py_session", session)
+
+        self._respect_ratelimit()
+
+        response: Optional[requests.Response] = None
+        try:
+            prepped = session.prepare_request(requests.Request(method, url, **kwargs))
+
+            if self._verbose_debug:
+                self._log_request(prepped)
+            elif self._debug:
+                logger.debug("%s %s", method, url)
+
+            settings = session.merge_environment_settings(prepped.url, {}, None, None, None)
+            response = session.send(prepped, **settings)
+
+            if self._debug:
+                logger.debug("response: status=%d length=%d", response.status_code, len(response.content))
+
+            self._update_ratelimit(response)
+            response.raise_for_status()
+            return response.json() if response.text else {}
+
+        except requests.HTTPError as exc:
+            if response is not None:
+                logger.error("HTTP %d: %s", response.status_code, response.text[:500])
+            try:
+                error_body = response.json() if response is not None else {}
+            except Exception:
+                error_body = {"error": response.text if response else "no response"}
+
+            raise ModrinthAPIError(
+                str(exc),
+                status_code=response.status_code if response is not None else None,
+                response=error_body,
+            ) from exc
+
+    @staticmethod
+    def _to_dict(obj: Any) -> DictKV:
+        return {k: v for k, v in obj.__dict__.items() if v is not None}
+
+    @staticmethod
+    def _open_files(paths: List[Path]) -> Iterator[Dict[str, IO[bytes]]]:
+        with ExitStack() as stack:
+            yield {f"file{i}": stack.enter_context(p.open("rb")) for i, p in enumerate(paths)}
+
+    def get_project(self, id_or_slug: str) -> DictKV:
+        """Fetch a project by its ID or slug."""
+        return self._request("GET", f"/project/{id_or_slug}")
+
+    def create_project(self, project: NewProject, icon_path: Optional[Path] = None) -> DictKV:
+        """Create a new project. Optionally attach an icon."""
+        payload = self._to_dict(project)
+        if "donation_urls" in payload:
+            payload["donation_urls"] = [du.__dict__ for du in payload["donation_urls"]]
+
+        if icon_path:
+            with icon_path.open("rb") as icon_file:
+                return self._request("POST", "/project", data={"data": json.dumps(payload)}, files={"icon": icon_file})
+        return self._request("POST", "/project", data={"data": json.dumps(payload)})
+
+    def modify_project(self, id_or_slug: str, update: ProjectUpdate) -> None:
+        """Partially update a project."""
+        self._request("PATCH", f"/project/{id_or_slug}", json=self._to_dict(update))
+
+    def change_project_icon(self, id_or_slug: str, icon_path: Path, ext: str) -> None:
+        """Replace the icon of a project."""
+        with icon_path.open("rb") as icon_file:
+            self._request("PATCH", f"/project/{id_or_slug}/icon", params={"ext": ext}, data=icon_file)
+
+    def get_project_versions(self, id_or_slug: str) -> ListDictKV:
+        """List all versions of a project."""
+        return self._request("GET", f"/project/{id_or_slug}/version")
+
+    def get_version(self, version_id: str) -> DictKV:
+        """Fetch a single version by its ID."""
+        return self._request("GET", f"/version/{version_id}")
+
+    def create_version(
+        self,
+        version: NewVersion,
+        file_paths: List[Path],
+        primary_file: Optional[str] = None,
+    ) -> DictKV:
+        """Upload a new version with one or more files."""
+        with ExitStack() as stack:
+            files = {f"file{i}": stack.enter_context(p.open("rb")) for i, p in enumerate(file_paths)}
+            payload: DictKV = {**version.__dict__, "file_parts": list(files.keys())}
+            if primary_file:
+                payload["primary_file"] = primary_file
+            return self._request("POST", "/version", data={"data": json.dumps(payload)}, files=files)
+
+    def modify_version(self, version_id: str, update: VersionUpdate) -> None:
+        """Partially update a version."""
+        self._request("PATCH", f"/version/{version_id}", json=self._to_dict(update))
+
+    def delete_version(self, version_id: str) -> None:
+        """Delete a version permanently."""
+        self._request("DELETE", f"/version/{version_id}")
+
+    def add_gallery_image(self, id_or_slug: str, image: GalleryImage) -> None:
+        """Upload an image to a project's gallery."""
+        params: DictKV = {"ext": image.ext, "featured": str(image.featured).lower()}
+        if image.title:
+            params["title"] = image.title
+        if image.description:
+            params["description"] = image.description
+        if image.ordering is not None:
+            params["ordering"] = image.ordering
+
+        with image.image_path.open("rb") as img_file:
+            self._request("POST", f"/project/{id_or_slug}/gallery", params=params, data=img_file)
+
+    def delete_gallery_image(self, id_or_slug: str, image_url: str) -> None:
+        """Remove an image from a project's gallery by its URL."""
+        self._request("DELETE", f"/project/{id_or_slug}/gallery", params={"url": image_url})
+
+    def get_organization_projects(self, organization_id: str) -> ListDictKV:
+        """List all projects belonging to an organization."""
+        return self._request("GET", f"/organization/{organization_id}/projects", api_version=3)
+
+    def get_game_versions(self) -> ListDictKV:
+        """Return all known game versions from the Modrinth tag API."""
+        return self._request("GET", "/tag/game_version")
+
+    def get_game_versions_until(self, cutoff_version: str) -> ListDictKV:
+        """Return game versions from newest down to and including ``cutoff_version``."""
+        return _cut_game_versions_until(cutoff_version, self.get_game_versions())
+
+    def get_loaders(self) -> ListDictKV:
+        """Return all known mod loaders from the Modrinth tag API."""
+        return self._request("GET", "/tag/loader")
+
+    @staticmethod
+    def parallel_requests(requests_list: List[Callable[[], Any]], max_parallel: int = 6) -> List[Any]:
+        """
+        Execute a list of callables in parallel using a thread pool.
+
+        Each callable should be a zero-argument function that calls one of the
+        client methods (e.g. ``lambda: client.get_project("sodium")``).
+        Results are returned in the same order as the input list.
+        Raises the first exception encountered, if any.
+        """
+        results: List[Any] = [None] * len(requests_list)
+
+        def _wrap(fn: Callable[[], Any]) -> Any:
+            try:
+                return fn()
+            except Exception as exc:
+                return exc
+
+        with ThreadPoolExecutor(max_workers=max_parallel) as executor:
+            future_to_index = {executor.submit(_wrap, fn): i for i, fn in enumerate(requests_list)}
+            for future in as_completed(future_to_index):
+                results[future_to_index[future]] = future.result()
+
+        for result in results:
+            if isinstance(result, Exception):
+                raise result
+
+        return results

modrinth4py/exceptions.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from typing import Optional, Dict, Any
+
+
+class ModrinthAPIError(Exception):
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        response: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.response = response or {}

modrinth4py/types.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+DictKV = Dict[str, Any]
+ListDictKV = List[DictKV]
+
+
+class SideSupport(str, Enum):
+    REQUIRED = "required"
+    OPTIONAL = "optional"
+    UNSUPPORTED = "unsupported"
+    UNKNOWN = "unknown"
+
+
+class ProjectStatus(str, Enum):
+    APPROVED = "approved"
+    ARCHIVED = "archived"
+    REJECTED = "rejected"
+    DRAFT = "draft"
+    UNLISTED = "unlisted"
+    PROCESSING = "processing"
+    WITHHELD = "withheld"
+    SCHEDULED = "scheduled"
+    PRIVATE = "private"
+    UNKNOWN = "unknown"
+
+
+class RequestedStatus(str, Enum):
+    APPROVED = "approved"
+    ARCHIVED = "archived"
+    UNLISTED = "unlisted"
+    PRIVATE = "private"
+    DRAFT = "draft"
+
+
+class ProjectType(str, Enum):
+    MOD = "mod"
+    MODPACK = "modpack"
+    RESOURCEPACK = "resourcepack"
+
+
+class VersionType(str, Enum):
+    RELEASE = "release"
+    BETA = "beta"
+    ALPHA = "alpha"
+
+
+class VersionStatus(str, Enum):
+    LISTED = "listed"
+    ARCHIVED = "archived"
+    DRAFT = "draft"
+    UNLISTED = "unlisted"
+    SCHEDULED = "scheduled"
+    UNKNOWN = "unknown"
+
+
+class RequestedVersionStatus(str, Enum):
+    LISTED = "listed"
+    ARCHIVED = "archived"
+    DRAFT = "draft"
+    UNLISTED = "unlisted"
+
+
+@dataclass
+class DonationUrl:
+    id: str
+    platform: str
+    url: str
+
+
+@dataclass
+class NewVersion:
+    name: str
+    version_number: str
+    project_id: str
+    game_versions: List[str]
+    loaders: List[str]
+    version_type: VersionType
+    featured: bool = True
+    changelog: Optional[str] = None
+    dependencies: Optional[List[DictKV]] = None
+    status: VersionStatus = VersionStatus.LISTED
+    requested_status: Optional[RequestedVersionStatus] = None
+
+
+@dataclass
+class NewProject:
+    slug: str
+    title: str
+    description: str
+    categories: List[str]
+    client_side: SideSupport
+    server_side: SideSupport
+    body: str
+    project_type: ProjectType
+    initial_versions: Optional[List[NewVersion]] = field(default_factory=list)
+    additional_categories: Optional[List[str]] = None
+    issues_url: Optional[str] = None
+    source_url: Optional[str] = None
+    organization_id: Optional[str] = None
+    wiki_url: Optional[str] = None
+    discord_url: Optional[str] = None
+    donation_urls: Optional[List[DonationUrl]] = None
+    requested_status: Optional[RequestedStatus] = RequestedStatus.UNLISTED
+    status: Optional[RequestedStatus] = RequestedStatus.DRAFT
+    license_id: Optional[str] = None
+    license_url: Optional[str] = None
+    is_draft: bool = True
+
+
+@dataclass
+class ProjectUpdate:
+    slug: Optional[str] = None
+    title: Optional[str] = None
+    description: Optional[str] = None
+    categories: Optional[List[str]] = None
+    client_side: Optional[str] = None
+    server_side: Optional[str] = None
+    body: Optional[str] = None
+    status: Optional[str] = None
+    requested_status: Optional[str] = None
+    additional_categories: Optional[List[str]] = None
+    issues_url: Optional[str] = None
+    source_url: Optional[str] = None
+    wiki_url: Optional[str] = None
+    discord_url: Optional[str] = None
+    donation_urls: Optional[List[Dict[str, Any]]] = None
+    license_id: Optional[str] = None
+    license_url: Optional[str] = None
+    moderation_message: Optional[str] = None
+    moderation_message_body: Optional[str] = None
+
+
+@dataclass
+class VersionUpdate:
+    name: Optional[str] = None
+    version_number: Optional[str] = None
+    changelog: Optional[str] = None
+    dependencies: Optional[List[DictKV]] = None
+    game_versions: Optional[List[str]] = None
+    version_type: Optional[VersionType] = None
+    loaders: Optional[List[str]] = None
+    featured: Optional[bool] = None
+    status: Optional[VersionStatus] = None
+    requested_status: Optional[RequestedVersionStatus] = None
+
+
+@dataclass
+class GalleryImage:
+    image_path: Path
+    ext: str
+    featured: bool
+    title: Optional[str] = None
+    description: Optional[str] = None
+    ordering: Optional[int] = None

modrinth4py-0.0.1.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: modrinth4py
+Version: 0.0.1
+Summary: A Python API client for the Modrinth API
+Author-email: rotgruengelb <daniel+modrinth4py@rotgruengelb.net>
+License: MIT
+Project-URL: Homepage, https://github.com/rotgruengelb/modrinth4py
+Project-URL: Documentation, https://github.com/rotgruengelb/modrinth4py#readme
+Project-URL: Source, https://github.com/rotgruengelb/modrinth4py
+Project-URL: Tracker, https://github.com/rotgruengelb/modrinth4py/issues
+Keywords: modrinth,api,client,minecraft,mods
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.32.5
+Dynamic: license-file
+
+# modrinth4py
+
+A Python API client for the [Modrinth](https://modrinth.com) API.
+
+## Installation
+
+```bash
+pip install modrinth4py
+```
+
+## Usage
+
+```python
+from modrinth4py import ModrinthClient, NewProject, SideSupport, ProjectType
+
+client = ModrinthClient(token="your-modrinth-pat")
+
+project = client.get_project("sodium")
+print(project["title"])
+```
+
+### Creating a project
+
+```python
+from modrinth4py import NewProject, SideSupport, ProjectType, RequestedStatus
+
+new_project = NewProject(
+    slug="my-mod",
+    title="My Mod",
+    description="A short description",
+    categories=["utility"],
+    client_side=SideSupport.REQUIRED,
+    server_side=SideSupport.OPTIONAL,
+    body="## My Mod\nLong-form description here.",
+    project_type=ProjectType.MOD,
+)
+
+result = client.create_project(new_project)
+```
+
+### Uploading a version
+
+```python
+from pathlib import Path
+from modrinth4py import NewVersion, VersionType
+
+version = NewVersion(
+    name="1.0.0",
+    version_number="1.0.0",
+    project_id="your-id",
+    game_versions=["1.21"],
+    loaders=["fabric"],
+    version_type=VersionType.RELEASE,
+    changelog="Initial release.",
+)
+
+client.create_version(version, file_paths=[Path("my-mod-1.0.0.jar")])
+```
+
+### Modifying a project
+
+```python
+from modrinth4py import ModrinthClient, ProjectUpdate
+
+client.modify_project("your-slug", ProjectUpdate(
+    discord_url="https://discord.gg/your-invite",
+    license_id="MIT",
+))
+```
+
+### Parallel requests
+
+```python
+projects = ModrinthClient.parallel_requests([
+    lambda: client.get_project("sodium"),
+    lambda: client.get_project("lithium"),
+    lambda: client.get_project("iris"),
+])
+```
+
+### Logging
+
+`modrinth4py` uses Python's standard `logging` module under the `modrinth4py.client` logger.
+Pass `debug=True` to `ModrinthClient` to enable debug output, or configure your own handler:
+
+```python
+import logging
+logging.basicConfig(level=logging.DEBUG)
+```
+
+## License
+
+MIT

modrinth4py-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+modrinth4py/__init__.py,sha256=Cp3MxwrWb4gmpeQ1qKI_ZZ4S1STEh6sFZ8LlmsrxBBc,764
+modrinth4py/client.py,sha256=sGZgxWkDFssVput4FsQPI_j3nFjcnot3m0vmhekbAXY,12574
+modrinth4py/exceptions.py,sha256=S_IFnnp6RFiovbq8K59UMIAF3mXsY8hQAI9-l1DfpVY,386
+modrinth4py/types.py,sha256=fEtqSPbFgkO_RejCuRotEYntZCnNWlcNFo5WShOnXGI,4058
+modrinth4py-0.0.1.dist-info/licenses/LICENSE,sha256=IL7dz7u4PKqCktqBnjQPytohvbRCQHJGJOKt47Fdr4g,1078
+modrinth4py-0.0.1.dist-info/METADATA,sha256=lGrUnp8XZoa2lqJMLteFKrpAN4P6aYD2h5OqRy3yewk,2822
+modrinth4py-0.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+modrinth4py-0.0.1.dist-info/top_level.txt,sha256=1b3U9jcyKxeA-JEDg-XY7zm6kmRAI12ggEY2ufgndlI,12
+modrinth4py-0.0.1.dist-info/RECORD,,

modrinth4py-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

modrinth4py-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 rotgruengelb
+
+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.

modrinth4py-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+modrinth4py