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

mcserver/__init__.py

@@ -1 +1 @@
-__version__ = "4.0.0.dev0"
+__version__ = "4.2.0"

mcserver/cli.py

@@ -1,23 +1,24 @@
 def main() -> int:
     import argparse
     import sys
+    from types import FunctionType
 
     from . import __version__
     from .modrinth.shared import search_sort_index
     from .shared import loader_list
 
-    def bound_int(min_integer: int, max_integer: int | None = None):
-        def parse(cli_string: str):
+    def bound_int(min_integer: int, max_integer: int | None = None) -> FunctionType:
+        def parse(cli_string: str) -> int:
             try:
                 integer = int(cli_string)
-            except TypeError:
+            except ValueError:
                 raise argparse.ArgumentTypeError(f"{cli_string} is not an integer")
 
-            if integer <= min_integer:
+            if integer < min_integer:
                 raise argparse.ArgumentTypeError(
                     f"{integer} must be higher than or equal to {min_integer}"
                 )
-            if max_integer is not None and integer >= max_integer:
+            if max_integer is not None and integer > max_integer:
                 raise argparse.ArgumentTypeError(
                     f"{integer} must be between {min_integer} and {max_integer} (inclusive)"
                 )
@@ -30,9 +31,9 @@ def main() -> int:
 
         match command_name:
             case "add":
-                from .commands import add_projects
+                from .commands import add
 
-                return add_projects(args)
+                return add(args)
             case "import":
                 from .commands import import_setup
 
@@ -42,9 +43,9 @@ def main() -> int:
 
                 return print_help(args)
             case "init":
-                from .commands import initialize_server
+                from .commands import init
 
-                return initialize_server(args)
+                return init(args)
             case "list":
                 from .commands import list_projects
 
@@ -66,25 +67,25 @@ def main() -> int:
 
                 return remove_projects(args)
             case "search":
-                from .commands import search_projects
+                from .commands import search
 
-                return search_projects(args)
+                return search(args)
             case "show":
-                from .commands import show_projects
+                from .commands import show
 
-                return show_projects(args)
+                return show(args)
             case "start":
-                from .commands import start_server
+                from .commands import start
 
-                return start_server(args)
+                return start(args)
             case "status":
                 from .commands import server_status
 
                 return server_status(args)
             case "stop":
-                from .commands import stop_server
+                from .commands import stop
 
-                return stop_server(args)
+                return stop(args)
             case "update":
                 from .commands import update_projects
 
@@ -134,28 +135,6 @@ def main() -> int:
 
     commands = parser.add_subparsers(title="Commands")
 
-    # 'add' command
-    add_command = commands.add_parser(
-        "add",
-        help="Add Modrinth projects to the server",
-        description="Add Modrinth mods/plugins to the server",
-    )
-
-    add_command.set_defaults(command_name="add")
-    add_command.add_argument(
-        "projects", nargs="+", type=str, help="Modrinth project slugs or IDs"
-    )
-
-    # 'import' command
-    import_command = commands.add_parser(
-        "import",
-        help="Import a Modrinth modpack",
-        description="Import a Modrinth modpack from a file.",
-    )
-
-    import_command.set_defaults(command_name="import")
-    import_command.add_argument("file", type=str, help="The Modrinth modpack file")
-
     # 'init' command
     init_command = commands.add_parser(
         "init",
@@ -193,15 +172,15 @@ def main() -> int:
     init_command.add_argument(
         "--min-ram",
         default=512,
-        type=bound_int(1024),
-        help="Minimum RAM for the server (in MebiBytes) (minimum value: 1024)",
+        type=bound_int(512),
+        help="Minimum RAM for the server (in MebiBytes) (minimum value: 512)",
         metavar="Size",
     )
 
     init_command.add_argument(
         "--max-ram",
-        default=bound_int(1024),
-        type=int,
+        default=1024,
+        type=bound_int(1024),
         help="Maximum RAM for the server (in MebiBytes) (minimum value: 1024)",
         metavar="Size",
     )
@@ -222,16 +201,9 @@ def main() -> int:
         choices=search_sort_index,
         help="Default search sort index",
         metavar="Index",
-        dest="search_limit",
-    )
-
-    # 'list' command
-    list_command = commands.add_parser(
-        "list", help="List all added projects", description="List all added projects."
+        dest="sort_index",
     )
 
-    list_command.set_defaults(command_name="list")
-
     # 'op' command
     op_command = commands.add_parser(
         "op", help="Manage operator players", description="Manage the operator status."
@@ -248,16 +220,6 @@ def main() -> int:
 
     op_list_command.set_defaults(command_name="op_list")
 
-    # 'remove' command
-    remove_command = commands.add_parser(
-        "remove", help="Remove projects", description="Remove projects"
-    )
-
-    remove_command.set_defaults(command_name="remove")
-    remove_command.add_argument(
-        "projects", nargs="+", type=str, help="Modrinth project slugs or IDs"
-    )
-
     # 'search' command
     search_command = commands.add_parser(
         "search",
@@ -272,7 +234,6 @@ def main() -> int:
 
     search_command.add_argument(
         "--limit",
-        default=20,
         type=bound_int(1, 100),
         help="Search projects per page (value between (inclusive): 1-100)",
         metavar="Number",
@@ -289,13 +250,11 @@ def main() -> int:
     )
 
     search_command.add_argument(
-        "--sort",
-        default="relevance",
+        "--sort-index",
         type=str,
         choices=search_sort_index,
         help="Sort by index",
         metavar="Index",
-        dest="sort_index",
     )
 
     search_command.add_argument(
@@ -348,6 +307,7 @@ def main() -> int:
 
     stop_command.set_defaults(command_name="stop")
 
+    # update is not going to be implemented in this version
     # 'whitelist' command
     whitelist_command = commands.add_parser(
         "whitelist",

mcserver/commands/__init__.py

@@ -1,37 +1,37 @@
-from .add_projects import main as add_projects
+from .add import add
 from .import_setup import main as import_setup
-from .initialize_server import main as initialize_server
+from .init import init
 from .list_projects import main as list_projects
 from .op_grant import main as op_grant
 from .op_list import main as op_list
 from .op_revoke import main as op_revoke
 from .print_help import main as print_help
 from .remove_projects import main as remove_projects
-from .search_projects import main as search_projects
+from .search import search
 from .server_status import main as server_status
-from .show_projects import main as show_projects
-from .start_server import main as start_server
-from .stop_server import main as stop_server
+from .show import show
+from .start import start
+from .stop import stop
 from .update_projects import main as update_projects
 from .whitelist_add import main as whitelist_add
 from .whitelist_list import main as whitelist_list
 from .whitelist_remove import main as whitelist_remove
 
 __all__ = [
-    "add_projects",
+    "add",
     "import_setup",
-    "initialize_server",
+    "init",
     "list_projects",
     "op_grant",
     "op_list",
     "op_revoke",
     "print_help",
     "remove_projects",
-    "search_projects",
+    "search",
     "server_status",
-    "show_projects",
-    "start_server",
-    "stop_server",
+    "show",
+    "start",
+    "stop",
     "update_projects",
     "whitelist_add",
     "whitelist_list",

mcserver/commands/add.py

@@ -0,0 +1,232 @@
+import logging
+from argparse import Namespace
+
+from .. import config, paths, shared
+from ..modrinth import apis as modrinth_apis
+from ..modrinth import project_records, slug_index
+from ..resolver import (
+    Dependency,
+    human_to_resolver,
+    required_only,
+    resolve_dependencies,
+)
+
+logger = logging.getLogger(__name__)
+
+def add(args: Namespace) -> int:
+    projects: list[str] = args.projects
+
+    if not (paths.configs_dir / "server.json").exists():
+        logger.error("Configuration file for server does not exist, is server initialized?")
+
+    server_config = config.read_config("server", shared.default_configs["server"]["format_version"])
+    game_version = server_config["game_version"]
+    loader_name = server_config["loader"]["name"]
+
+    if loader_name == "vanilla":
+        logger.error("Vanilla does not support mod or plugin.")
+        return 1
+
+    project_ids: list[str] = []
+    for project in projects:
+        modrinth_apis.get_project_versions(project, loader_name, game_version)
+
+    def get_dependencies(project_id: str) -> dict[str, int]:
+        dependencies: list[Dependency] = []
+        if project_records.record_exists(project_id):
+            project_record = project_records.read_record(project_id)
+            for dependency_id, dependency_type in project_record["dependencies"].items():
+                dependencies.append({
+                    "project_id": dependency_id,
+                    "dependency_type": dependency_type
+                })
+
+        else:
+            project_version = modrinth_apis.get_project_versions(
+                project_id, loader_name, game_version, include_changelog=False
+            )[0]
+
+            if "dependencies" in project_version:
+                project_dependencies = project_version["dependencies"]
+                for dependency in project_dependencies:
+                    if not "project_id" in dependency:
+                        continue
+
+                    if dependency["project_id"] is None:
+                        continue
+
+                    dependencies.append(
+                        {
+                            "project_id": dependency["project_id"],
+                            "dependency_type": dependency["dependency_type"],
+                        }
+                    )
+
+        return human_to_resolver(dependencies)
+
+    resolved_dependencies = resolve_dependencies(projects, get_dependencies, required_only)
+    print(resolved_dependencies)
+    return 0
+
+    # # from ..modrinth.apis import get_project_versions
+
+    # def get_project_versions(
+    #     project_id, loader_names, game_versions, featured=None, include_changelog=True
+    # ):
+    #     project_version = {
+    #         "embeddium": {
+    #             "dependencies": [
+    #                 {"project_id": "AANobbMI", "dependency_type": "incompatible"}
+    #             ],
+    #             "project_id": "sk9rgfiA",
+    #         },
+    #         "fabric-api": {"dependencies": [], "project_id": "P7dR8mSH"},
+    #         "jade": {
+    #             "dependencies": [
+    #                 {"project_id": "AANobbMI", "dependency_type": "required"},
+    #                 {"project_id": "u6dRKJwZ", "dependency_type": "optional"},
+    #             ],
+    #             "project_id": "nvQzSEkH",
+    #         },
+    #         "jei": {"dependencies": [], "project_id": "u6dRKJwZ"},
+    #         "just-enough-resources-jer": {
+    #             "dependencies": [
+    #                 {"project_id": "u6dRKJwZ", "dependency_type": "required"}
+    #             ],
+    #             "project_id": "uEfK2CXF",
+    #         },
+    #         "origins": {
+    #             "dependencies": [
+    #                 {"project_id": "P7dR8mSH", "dependency_type": "required"}
+    #             ],
+    #             "project_id": "3BeIrqZR",
+    #         },
+    #         "pehkui": {
+    #             "dependencies": [
+    #                 {"project_id": "P7dR8mSH", "dependency_type": "required"}
+    #             ],
+    #             "project_id": "t5W7Jfwy",
+    #         },
+    #         "podium": {
+    #             "dependencies": [
+    #                 {"project_id": "AANobbMI", "dependency_type": "required"}
+    #             ],
+    #             "project_id": "fW8woQj4",
+    #         },
+    #         "sodium": {"dependencies": [], "project_id": "AANobbMI"},
+    #         "thdilos-fox-origin-expanded": {
+    #             "dependencies": [
+    #                 {"project_id": "9qGn08Dr", "dependency_type": "required"},
+    #                 {"project_id": "3BeIrqZR", "dependency_type": "required"},
+    #                 {"project_id": "t5W7Jfwy", "dependency_type": "required"},
+    #             ],
+    #             "project_id": "CbsRGXBx",
+    #         },
+    #         "thdilos-fox-origin": {
+    #             "dependencies": [
+    #                 {"project_id": "3BeIrqZR", "dependency_type": "required"},
+    #                 {"project_id": "t5W7Jfwy", "dependency_type": "required"},
+    #             ],
+    #             "project_id": "9qGn08Dr",
+    #         },
+    #     }
+
+    #     id_slug = {
+    #         "3BeIrqZR": "origins",
+    #         "9qGn08Dr": "thdilos-fox-origin",
+    #         "AANobbMI": "sodium",
+    #         "CbsRGXBx": "thdilos-fox-origin-expanded",
+    #         "P7dR8mSH": "fabric-api",
+    #         "fW8woQj4": "podium",
+    #         "nvQzSEkH": "jade",
+    #         "sk9rgfiA": "embeddium",
+    #         "t5W7Jfwy": "pehkui",
+    #         "u6dRKJwZ": "jei",
+    #         "uEfK2CXF": "just-enough-resources-jer",
+    #     }
+
+    #     a = [
+    #         (
+    #             project_version[project_id]
+    #             if project_id in project_version
+    #             else project_version[id_slug[project_id]]
+    #         )
+    #     ]
+    #     return a
+
+
+    # server_config = config.read_config(
+    #     "server", shared.default_configs["server"]["format_version"]
+    # )
+    # loader_name = server_config["loader"]["name"]
+    # game_version = server_config["game_version"]
+
+    # cached_project_versions = {}
+    # project_ids = []
+
+    # for project in projects:
+    #     project_version = get_project_versions(
+    #         project, loader_name, game_version, include_changelog=False
+    #     )[0]
+
+    #     cached_project_versions[project_version["project_id"]] = project_version
+    #     project_ids.append(project_version["project_id"])
+
+    # id_to_slug: dict[str, str] = {}
+
+    # def get_dependencies(project_id: str) -> dict[str, int]:
+    #     dependencies: list[Dependency] = []
+
+    #     # Get the latest version
+    #     project_version = get_project_versions(
+    #         project_id, loader_name, game_version, include_changelog=False
+    #     )[0]
+    #     if "dependencies" in project_version:
+    #         project_dependencies = project_version["dependencies"]
+    #         for dependency in project_dependencies:
+    #             if not "project_id" in dependency:
+    #                 continue
+
+    #             if dependency["project_id"] is None:
+    #                 continue
+
+    #             dependencies.append(
+    #                 {
+    #                     "project_id": dependency["project_id"],
+    #                     "dependency_type": dependency["dependency_type"],
+    #                 }
+    #             )
+
+    #     return human_to_resolver(dependencies)
+
+    # def required_only(dependency_type: int) -> bool:
+    #     return dependency_type == 2
+
+    # resolved_projects = resolver_to_human(
+    #         resolve_dependencies(project_ids, get_dependencies, required_only)
+    #     )
+
+    # print(json.dumps(resolved_projects, indent=2))
+
+    # required_projects: set[str] = set()
+    # optional_projects: set[str] = set()
+    # incompatible_projects: set[str] = set()
+
+    # for project in resolved_projects:
+    #     for dependent in project["dependents"]:
+    #         match dependent["dependency_type"]:
+    #             case "required":
+    #                 required_projects.add(project["project_id"])
+    #             case "optional":
+    #                 optional_projects.add(project["project_id"])
+    #             case "incompatible":
+    #                 incompatible_projects.add(project["project_id"])
+
+    # conflicting_projects: set[str] = required_projects & incompatible_projects
+
+    # if conflicting_projects:
+    #     print(f"I think we have conflicting project -_-, like {conflicting_projects} are in required and incompatible")
+
+    # print(required_projects, optional_projects, incompatible_projects, conflicting_projects)
+
+    # return 0

mcserver/commands/{initialize_server.py → init.py}

@@ -1,7 +1,7 @@
 from argparse import Namespace
 
 
-def main(args: Namespace) -> int:
+def init(args: Namespace) -> int:
     from ..modrinth.shared import SearchSortIndex
 
     # CLI Arguments
@@ -23,6 +23,19 @@ def main(args: Namespace) -> int:
     from .. import __version__, config, shared, state
     from ..metadata import metadata_file, set_metadata
 
+    if min_ram > max_ram:
+        log.error("Minimum RAM cannot be larger than maximum RAM")
+        return 1
+
+    # Is first initializing
+    is_first_initialize = not metadata_file.exists()
+
+    if not is_first_initialize:
+        log.info("Server is already initialized, exiting...")
+        return 1
+
+    shared.set_loader_context(loader_name)
+
     # Special loader version
     if loader_name == "vanilla":
         loader_version = None
@@ -33,9 +46,11 @@ def main(args: Namespace) -> int:
 
         match game_version:
             case "latest" | "latest-release":
+                log.info("Fetching the latest release version for Minecraft...")
                 game_version = mojang_manifest.get_latest_release_version()
                 log.info(f"Latest Minecraft release version is: {game_version}")
             case "latest-snapshot":
+                log.info("Fetching the latest snapshot version for Minecraft...")
                 game_version = mojang_manifest.get_latest_snapshot_version()
                 log.info(f"Latest Minecraft snapshot version is: {game_version}")
 
@@ -44,6 +59,7 @@ def main(args: Namespace) -> int:
         match loader_name:
             # Mod Loaders
             case "fabric":
+                log.info("Fetching the latest version for Fabric Loader...")
                 from ..fabricmc import meta as fabricmc_meta
 
                 loader_versions = fabricmc_meta.get_loader_versions()
@@ -53,9 +69,10 @@ def main(args: Namespace) -> int:
                         break
 
                 log.info(f"Latest Fabric loader version is: {loader_version}")
-            case "legacyfabric":
-                pass
+            # case "legacy_fabric":
+            #     pass
             case "quilt":
+                log.info("Fetching the latest version for Quilt Loader...")
                 from ..quiltmc import meta as quiltmc_meta
 
                 loader_versions = quiltmc_meta.get_loader_versions()
@@ -64,6 +81,7 @@ def main(args: Namespace) -> int:
                 log.info(f"Latest Quilt loader version is: {loader_version}")
             # Plugin Loader
             case "paper":
+                log.info("Fetching the latest version for Paper...")
                 from ..papermc import api as papermc_api
 
                 latest_paper_version = papermc_api.get_latest_project_build(
@@ -72,6 +90,7 @@ def main(args: Namespace) -> int:
                 loader_version = str(latest_paper_version["build_id"])
                 log.info(f"Latest Paper build version is: {loader_version}")
             case "purpur":
+                log.info("Fetching the latest version for Purpur...")
                 from ..purpurmc import api as purpurmc_api
 
                 latest_purpur_version = purpurmc_api.get_latest_project_build(
@@ -84,9 +103,9 @@ def main(args: Namespace) -> int:
                 log.error(f"Unknown loader: {loader_name}")
                 return 1
 
-    # Is first initializing
-    is_first_initialize = not metadata_file.exists()
-    shared.set_loader_context(loader_name)
+        if loader_version == "latest":
+            log.error("No stable version found")
+            return 1
 
     shared.mcserver_dir.mkdir(exist_ok=True)
     state.set_state("initializing_server")
@@ -97,8 +116,9 @@ def main(args: Namespace) -> int:
         shared.loader_context["project_directory"].mkdir(exist_ok=True)
 
     # Write configuration to file
-    for config_name in shared.default_configs.keys():
-        default_config = copy.deepcopy(shared.default_configs[config_name])
+    for config_name in shared.default_configs:
+        configuration = shared.default_configs[config_name]
+        default_config = copy.deepcopy(configuration["config_data"])
 
         config_override: dict = {}
         match config_name:
@@ -119,14 +139,18 @@ def main(args: Namespace) -> int:
 
         config_data = shared.merge_dict(default_config, config_override)
         try:
-            config.generate_config(config_name, config_data)
+            config.write_config(
+                config_name, configuration["format_version"], config_data
+            )
         except FileExistsError:
-            log.debug(f"Configuration file {config_name} already exists")
+            if is_first_initialize:
+                log.debug(f"Configuration file {config_name} already exists")
+            else:
+                log.info(
+                    f"Configuration for '{config_name}' already exist, skipping..."
+                )
 
-    if is_first_initialize:
-        set_metadata(__version__)
-        log.info("Initialized server configurations.")
-    else:
-        log.info("Reinitialized server configurations.")
+    set_metadata(__version__)
+    log.info("Initialized server configurations.")
 
     return 0