mcserver-cli 4.0.0.dev0__py3-none-any.whl → 4.2.0__py3-none-any.whl

mcserver/commands/search.py

@@ -0,0 +1,183 @@
+import logging
+import math
+from argparse import Namespace
+
+from mcserver import paths
+
+from .. import config
+from ..modrinth import apis as modrinth_apis
+from ..modrinth.shared import SearchSortIndex
+from ..shared import (
+    default_configs,
+    format_number,
+    get_loader_context,
+    pluralize,
+    project_environment_name,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def search(args: Namespace) -> int:
+    search_query: list[str] = args.search_query
+    search_limit: int | None = args.search_limit
+    page_number: int = args.page_number
+    sort_index: SearchSortIndex | None = args.sort_index
+    game_version: str | None = args.game_version
+    no_version: str = args.no_version
+    loader_name: str | None = args.loader_name
+
+    if search_limit is None or sort_index is None:
+        modrinth_default_config = default_configs["modrinth"]
+        modrinth_config_path = paths.configs_dir / "modrinth.json"
+
+        if search_limit is None:
+            search_limit = modrinth_default_config["config_data"]["search_limit"]
+            logger.debug(
+                f"search_limit is set to default modrinth configuration: {search_limit}"
+            )
+
+        if sort_index is None:
+            sort_index = modrinth_default_config["config_data"]["sort_index"]
+            logger.debug(
+                f"sort_index is set to default modrinth configuration: {sort_index}"
+            )
+
+        if modrinth_config_path.exists():
+            modrinth_config = config.read_config(
+                "modrinth", modrinth_default_config["format_version"]
+            )
+            if search_limit is None and "search_limit" in modrinth_config:
+                search_limit = modrinth_config["search_limit"]
+                logger.debug(
+                    f"search_limit is set to modrinth configuration file: {search_limit}"
+                )
+
+            if sort_index is None and "sort_index" in modrinth_config:
+                sort_index = modrinth_config["sort_index"]
+                logger.debug(
+                    f"sort_index is set to modrinth configuration file: {sort_index}"
+                )
+
+    if game_version is None or loader_name is None:
+        server_config_path = paths.configs_dir / "server.json"
+
+        if server_config_path.exists():
+            server_config = config.read_config(
+                "server", default_configs["server"]["format_version"]
+            )
+            if game_version is None and "game_version" in server_config:
+                game_version = server_config["game_version"]
+                logger.debug(
+                    f"game_version is set to server configuration file: {game_version}"
+                )
+
+            if (
+                loader_name is None
+                and "loader" in server_config
+                and "name" in server_config["loader"]
+            ):
+                loader_name = server_config["loader"]["name"]
+                logger.debug(
+                    f"loader_name is set to server configuration file: {loader_name}"
+                )
+
+    if no_version:
+        game_version = None
+        logger.debug("game_version is set to None because of no_version")
+
+    if search_limit is None:
+        logger.error("search_limit is None (somehow, really!)")
+        return 1
+
+    if sort_index is None:
+        logger.error("sort_index is None (somehow, really!)")
+        return 1
+
+    if loader_name == "vanilla":
+        logger.error("Vanilla does not support mods or plugin.")
+        return 1
+
+    project_label, _ = get_loader_context(loader_name)
+
+    search_offset = search_limit * (page_number - 1)
+    search_facets = [
+        ["environment!=singleplayer_only"],
+    ]
+
+    if game_version is not None:
+        search_facets.append([f"versions:{game_version}"])
+
+    if loader_name is not None:
+        search_facets.append([f"project_type:{project_label}"])
+        search_facets.append([f"categories:{loader_name}"])
+    else:
+        search_facets.append(["project_type:mod","project_type:plugin"])
+
+    search_info = f"Searching {pluralize(project_label, search_limit)}"
+    if search_query:
+        search_info += f" with '{' '.join(search_query)}'"
+
+    if game_version or loader_name:
+        search_info += " for"
+
+    if game_version:
+        search_info += f" Minecraft {game_version},"
+
+    if loader_name:
+        search_info += f" {loader_name.capitalize()}"
+
+    search_info += f" sorted by {sort_index}..."
+
+    logger.info(search_info)
+    search_result = modrinth_apis.search_projects(
+        search_query, search_facets, sort_index, search_offset, search_limit
+    )
+
+    total_hits = search_result["total_hits"]
+    total_pages = math.ceil(total_hits / search_limit)
+
+    search_hits = search_result["search_hits"]
+
+    if search_result["total_hits"] == 0:
+        logger.error(f"No {project_label} found.")
+        return 1
+
+    if page_number > total_pages:
+        logger.error(
+            f"Page number is larger than total pages of {total_pages} available"
+        )
+        return 1
+
+    logger.info(
+        f"Showing {len(search_hits)} {pluralize(project_label, len(search_hits))} out of {total_hits:,} {pluralize(project_label, total_hits)} (Page {page_number} out of {total_pages})"
+    )
+
+    for count, hit in enumerate(search_hits):
+        slug_or_id = hit["project_slug"] if "project_slug" in hit else hit["project_id"]
+        project_author = f"by {hit['author_username']}"
+
+        environments: list[Environment] = hit["environments"]
+        if len(environments) == 0:
+            environments.append("No environment")
+
+        readable_environments: list[str] = []
+        for environment in environments:
+            readable_environments.append(project_environment_name(environment))
+
+        print(
+            f"{hit['project_name']} ({slug_or_id}) {project_author}"
+        )
+        print(f"> Downloads: {format_number(hit['download_count'])} | Follows: {format_number(hit['follower_count'])}")
+        print(
+            f"> {', '.join(readable_environments)}"
+        )
+        print(f"> https://modrinth.com/{hit['all_project_types'][0]}/{slug_or_id}")
+        print(
+            f"  {hit['short_description']}"
+        )
+
+        if (count + 1) < len(search_hits):
+            print()  # Print newline for readability
+
+    return 0

mcserver/commands/show.py

@@ -0,0 +1,105 @@
+from argparse import Namespace
+
+
+def show(args: Namespace) -> int:
+    projects: list[str] = args.projects
+
+    import logging
+
+    from .. import shared
+    from ..modrinth import apis as modrinth_api
+    from ..shared import format_number, pluralize
+
+    logger = logging.getLogger(__name__)
+
+    logger.info(f"Getting {pluralize('project', len(projects))} informations...")
+    project_informations = modrinth_api.get_project_informations(projects)
+
+    logger.info(
+        f"Showing {len(project_informations)} out of {len(projects)} {pluralize('project', len(project_informations))}."
+    )
+    for project_information in project_informations:
+        slug_or_id = project_information.get(
+            "project_slug", project_information["project_id"]
+        )
+        print(f"Name: {project_information['project_name']} ({slug_or_id})")
+
+        download_count = project_information["download_count"]
+        print(
+            f"{pluralize('Download', download_count)}: {format_number(download_count)}"
+        )
+
+        follower_count = project_information["follower_count"]
+        print(
+            f"{pluralize('Follower', follower_count)}: {format_number(follower_count)}"
+        )
+
+        categories = project_information["categories"]
+        readable_categories: list[str] = []
+        for category in categories:
+            readable_categories.append(category.replace("-", " ").title())
+        print(
+            f"{pluralize('Category', len(categories))}: {', '.join(readable_categories)}"
+        )
+
+        if "additional_categories" in project_information:
+            additional_categories = project_information["additional_categories"]
+            readable_additional_categories: list[str] = []
+            for additional_category in additional_categories:
+                readable_additional_categories.append(
+                    additional_category.replace("-", " ").title()
+                )
+            print(
+                f"Additional {pluralize('Category', len(additional_categories))}: {', '.join(readable_additional_categories)}"
+            )
+
+        loader_names = project_information["loader_names"]
+        loaders: list[str] = []
+        for loader in loader_names:
+            loaders.append(loader.title())
+        print(f"{pluralize('Loader', len(loader_names))}: {', '.join(loaders)}")
+
+        game_versions = project_information["game_versions"]
+        print(
+            f"Minecraft {pluralize('Version', len(game_versions))}: {', '.join(game_versions)}"
+        )
+
+        environments = project_information["environments"]
+        readable_environments: list[str] = []
+        for environment in environments:
+            readable_environments.append(shared.project_environment_name(environment))
+        print(
+            f"{pluralize('Environment', len(environments))}: {', '.join(readable_environments)}"
+        )
+
+        project_license = project_information["project_license"]
+        license_string = ""
+        if "license_name" in project_license:
+            license_string = project_license["license_name"]
+
+        if "license_id" in project_license:
+            if license_string != "":
+                license_string += f"({project_license['license_id']})"
+            else:
+                license_string = project_license["license_id"]
+        print(f"License: {license_string}")
+
+        print(
+            f"Homepage: https://modrinth.com/{project_information['project_type']}/{slug_or_id}"
+        )
+
+        if "source_url" in project_information:
+            print(f"Source Code: {project_information['source_url']}")
+
+        if "issues_url" in project_information:
+            print(f"Issues: {project_information['issues_url']}")
+
+        if "wiki_url" in project_information:
+            print(f"Wiki: {project_information['wiki_url']}")
+
+        if "discord_url" in project_information:
+            print(f"Discord: {project_information['discord_url']}")
+
+        print(f"Description: {project_information['short_description']}")
+
+    return 0

mcserver/commands/{start_server.py → start.py}

@@ -1,7 +1,7 @@
 from argparse import Namespace
 
 
-def main(args: Namespace) -> int:
+def start(args: Namespace) -> int:
     import logging as log
 
     from .. import state
@@ -13,9 +13,16 @@ def main(args: Namespace) -> int:
 
     current_state = state.get_state()
     if current_state["is_active"]:
-        log.error(
-            f"There's another active MCServer process ({current_state['action']}) running with process ID: {current_state['process_id']}"
-        )
+        error_message = "There's another active MCServer process"
+        if "action" in current_state:
+            error_message += f" ({current_state['action']})"
+        error_message += " running"
+
+        if "process_id" in current_state:
+            error_message += f" with process ID: {current_state['process_id']}"
+        error_message += "."
+
+        log.error(error_message)
         return 1
 
     # Set state
@@ -25,10 +32,12 @@ def main(args: Namespace) -> int:
     import shutil
     from pathlib import Path
 
-    from .. import config
+    from .. import config, shared
 
     # Load configs
-    launcher_config = config.load_config("launcher")
+    launcher_config = config.read_config(
+        "launcher", shared.default_configs["launcher"]["format_version"]
+    )
 
     jarfile = Path(launcher_config["jarfile"])
     memory_config = launcher_config["ram"]
@@ -41,7 +50,9 @@ def main(args: Namespace) -> int:
 
         state.set_state("downloading_server")
 
-        server_config = config.load_config("server")
+        server_config = config.read_config(
+            "server", shared.default_configs["server"]["format_version"]
+        )
         game_version = server_config["game_version"]
         server_loader = server_config["loader"]
 
@@ -61,16 +72,17 @@ def main(args: Namespace) -> int:
                     f"Downloading Fabric loader {loader_version} for Minecraft version {game_version}..."
                 )
                 networking.download(
-                    fabricmc_meta.download_url(game_version, loader_version, "1.0.1"),
+                    fabricmc_meta.download_url(game_version, loader_version, "1.1.2"),
                     jarfile,
                 )
 
-            #            case "quilt":
-            #                log.info(f"Downloading Quilt loader {loader_version} for Minecraft version {game_version}...")
-            #                networking.download(f"https://")
+            # case "quilt":
+            #     from ..quiltmc import meta
+            #     log.info(f"Downloading Quilt loader {loader_version} for Minecraft version {game_version}...")
+            #     networking.download(meta., jarfile)
 
-            #            case "legacy-fabric":
-            #                pass
+            # case "legacy-fabric":
+            #     pass
 
             # Plugin loaders
             case "paper":
@@ -86,7 +98,7 @@ def main(args: Namespace) -> int:
                 networking.download(
                     download_prop["download_url"],
                     jarfile,
-                    hashes=download_prop["file_hashes"],
+                    hashes={"sha256": download_prop["file_hashes"]["sha256"]},
                 )
             case "purpur":
                 from ..purpurmc import api as purpurmc_api

mcserver/commands/{stop_server.py → stop.py}

@@ -1,22 +1,14 @@
 from argparse import Namespace
 
 
-def main(args: Namespace) -> int:
-    # CLI arguments
-    force_stop: bool = args.force_stop
-
+def stop(args: Namespace) -> int:
     import logging as log
     import os
     from signal import SIGTERM
 
     from .. import state
 
-    try:
-        current_state = state.get_state()
-    except FileNotFoundError:
-        log.error(f"File '{state.state_file}' not found; MCServer not initialized.")
-        return 1
-
+    current_state = state.get_state()
     if not current_state["is_active"]:
         log.error("Server is not running.")
         return 1

mcserver/config.py

@@ -1,5 +1,6 @@
 # Modules
 # Standard
+import copy
 import json
 from typing import Any
 
@@ -32,9 +33,11 @@ def write_config(
 
     config_filename = f"{config_name}.json"
     config_path = configs_dir / config_filename
-    config_data["format_version"] = format_version
 
-    config_json = json.dumps(config_data)
+    configuration_data = {"format_version": format_version}
+
+    configuration_data.update(copy.deepcopy(config_data))
+    config_json = json.dumps(configuration_data, indent=2)
     config_path.write_text(config_json)
 
 
@@ -61,6 +64,8 @@ def read_config(config_name: str, current_format_version: int) -> dict[str, Any]
     config_data = json.loads(config_json)
 
     if config_data["format_version"] > current_format_version:
-        raise ConfigVersionError("")
+        raise ConfigVersionError(
+            f"The configuration for {config_name}'s format version is higher than this version of MCServer."
+        )
 
     return config_data

mcserver/fabricmc/meta.py

@@ -38,4 +38,4 @@ def get_loader_versions() -> list[LoaderVersion]:
 
 
 def download_url(game_version: str, loader_version: str, installer_version) -> str:
-    return f"{fabricmc_meta_url}/v2/versions/loader/{loader_version}/{game_version}/{installer_version}/server/jar"
+    return f"{fabricmc_meta_url}/v2/versions/loader/{game_version}/{loader_version}/{installer_version}/server/jar"

mcserver/metadata.py

@@ -4,24 +4,24 @@ import json
 from typing import TypedDict
 
 # MCServer
-from .shared import mcserver_dir
+from .paths import metadata_file
 
+metadata_format_version = 1
+
+class MetadataFormatVersionError(Exception): pass
 
 class MCServerMetadata(TypedDict):
     version: str
 
 
 class Metadata(TypedDict):
+    format_version: int
     mcserver: MCServerMetadata
 
 
-# Paths
-metadata_file = mcserver_dir / "metadata.json"
-
-
 # Functions
 def set_metadata(mcserver_version: str) -> None:
-    metadata: Metadata = {"mcserver": {"version": mcserver_version}}
+    metadata: Metadata = {"format_version": metadata_format_version,"mcserver": {"version": mcserver_version}}
 
     metadata_data: str = json.dumps(metadata)
     metadata_file.write_text(metadata_data)
@@ -30,4 +30,6 @@ def set_metadata(mcserver_version: str) -> None:
 def get_metadata() -> Metadata:
     metadata_data = metadata_file.read_text()
     metadata: Metadata = json.loads(metadata_data)
+    if metadata["format_version"] > metadata_format_version:
+        raise MetadataFormatVersionError("Existing metadata format version is higher than current metadata format version")
     return metadata

mcserver/modrinth/apis/__init__.py

@@ -1,9 +1,9 @@
-# from .get_project_versions import main as get_project_versions
-# from .search_projects import main as search_projects
-from .get_project_informations import main as get_project_informations
+from .get_project_informations import get_project_informations
+from .get_project_versions import get_project_versions
+from .search_projects import search_projects
 
 __all__ = [
-    # "get_project_versions",
     "get_project_informations",
-    # "search_projects",
+    "get_project_versions",
+    "search_projects",
 ]

mcserver/modrinth/apis/get_project_informations.py

@@ -1,18 +1,18 @@
 from ..typings import ProjectInformation
 
 
-class GetProjectInformationError(Exception):
+class GetProjectInformationsError(Exception):
     pass
 
 
-def main(project_ids: list[str] | str) -> list[ProjectInformation]:
+def get_project_informations(project_ids: list[str] | str) -> list[ProjectInformation]:
     """Get information about Modrinth projects
 
     Args:
         project_ids: The ID of the projects
 
     Returns:
-        List of project informations
+        List of information for the projects
     """
     if isinstance(project_ids, str):
         project_ids = [project_ids]
@@ -27,10 +27,12 @@ def main(project_ids: list[str] | str) -> list[ProjectInformation]:
         Environment,
         EnvironmentSide,
         GalleryImage,
+        ModeratorMessage,
         MonetizationStatus,
         ProjectLicense,
         ProjectStatus,
         ProjectType,
+        RequestedProjectStatus,
     )
 
     query_parameters = {"ids": json.dumps(project_ids)}
@@ -40,7 +42,7 @@ def main(project_ids: list[str] | str) -> list[ProjectInformation]:
     )
 
     if "json" not in response:
-        raise GetProjectInformationError("Cannot load JSON response")
+        raise GetProjectInformationsError("Cannot load JSON response")
 
     project_informations: list[ProjectInformation] = []
     for information in response["json"]:
@@ -57,6 +59,12 @@ def main(project_ids: list[str] | str) -> list[ProjectInformation]:
         if monetization_status not in shared.MONETIZATION_STATUS:
             log.warning(f"Unknown monetization status: {monetization_status}")
 
+        requested_project_status: RequestedProjectStatus = information[
+            "requested_status"
+        ]
+        if requested_project_status not in shared.REQUESTED_PROJECT_STATUS:
+            log.warning(f"Unknown monetization status: {monetization_status}")
+
         client_side: EnvironmentSide = information["client_side"]
         if client_side not in shared.ENVIRONMENT_SIDE:
             log.warning(f"Unknown client side: {client_side}")
@@ -66,33 +74,11 @@ def main(project_ids: list[str] | str) -> list[ProjectInformation]:
             log.warning(f"Unknown server side: {server_side}")
 
         # Lists
-        categories: list[str] = []
-        for category in information["categories"]:
-            categories.append(category)
-
-        additional_categories: list[str] = []
-        for additional_category in information["additional_categories"]:
-            additional_categories.append(additional_category)
-
-        environments: list[Environment] = []
-        for environment in information["environment"]:
+        environments: list[Environment] = information["environment"]
+        for environment in environments:
             if environment not in shared.ENVIRONMENT:
                 log.warning(f"Unknown environment: {environment}")
 
-            environments.append(environment)
-
-        game_versions: list[str] = []
-        for game_version in information["game_versions"]:
-            game_versions.append(game_version)
-
-        loader_names: list[str] = []
-        for loader_name in information["loaders"]:
-            loader_names.append(loader_name)
-
-        version_ids: list[str] = []
-        for version_id in information["versions"]:
-            version_ids.append(version_id)
-
         gallery: list[GalleryImage] = []
         for image in information["gallery"]:
             gallery_image: GalleryImage = {
@@ -148,12 +134,12 @@ def main(project_ids: list[str] | str) -> list[ProjectInformation]:
             "description": information["body"],
             "project_status": project_status,
             "project_type": project_type,
-            "categories": categories,
-            "additional_categories": additional_categories,
+            "categories": information["categories"],
+            "additional_categories": information["additional_categories"],
             "environments": environments,
-            "game_versions": game_versions,
-            "loader_names": loader_names,
-            "version_ids": version_ids,
+            "game_versions": information["game_versions"],
+            "loader_names": information["loaders"],
+            "version_ids": information["versions"],
             "project_license": project_license,
             "published_time": information["published"],
             "updated_time": information["updated"],
@@ -173,7 +159,7 @@ def main(project_ids: list[str] | str) -> list[ProjectInformation]:
             project_information["organization_id"] = information["organization"]
 
         if "requested_status" in information:
-            project_information["requested_status"] = information["requested_status"]
+            project_information["requested_project_status"] = requested_project_status
 
         if "approved" in information:
             project_information["approved_time"] = information["approved"]
@@ -209,7 +195,19 @@ def main(project_ids: list[str] | str) -> list[ProjectInformation]:
             project_information["body_url"] = information["body_url"]
 
         if "moderator_message" in information:
-            project_information["moderator_message"] = information["moderator_message"]
+            moderator_message: ModeratorMessage | None = None
+            if information["moderator_message"] is not None:
+                moderator_message = {}
+                information_moderator_message = information["moderator_message"]
+                if "message" in information_moderator_message:
+                    moderator_message["message"] = information_moderator_message[
+                        "message"
+                    ]
+
+                if "body" in information_moderator_message:
+                    moderator_message["body"] = information_moderator_message["body"]
+
+            project_information["moderator_message"] = moderator_message
 
         project_informations.append(project_information)