mcserver-cli 3.0.0__py3-none-any.whl

mcserver/modrinth/modpack.py

@@ -0,0 +1,101 @@
+# Modules
+# Standard
+import json
+import zipfile
+from pathlib import Path
+from typing import Literal, NotRequired, TypedDict
+
+
+# TYpedDict
+class FileHashes(TypedDict):
+    sha1: str  # original: sha1
+    sha512: str  # original: sha512
+
+
+class ModEnvironment(TypedDict):
+    client_side: Literal[
+        "required", "optional", "unsupported", "unknown"
+    ]  # original: client
+    server_side: Literal[
+        "required", "optional", "unsupported", "unknown"
+    ]  # original: server
+
+
+class ModpackFile(TypedDict):
+    file_path: Path  # original: path
+    hashes: FileHashes  # original: hashes
+    mod_environment: NotRequired[ModEnvironment]  # original: env
+    download_urls: list[str]  # original: downloads
+    file_size: int  # original: fileSize
+
+
+class ModpackIndex(TypedDict):
+    format_version: int  # original: formatVersion
+    game_name: Literal["minecraft"]  # original: game
+    version_id: str  # original: versionId
+    pack_name: str  # original: name
+    summary: NotRequired[str]  # original: summary
+    files: list[ModpackFile]  # original: files
+    dependencies: dict[str, str]  # original: dependencies
+
+
+# Functions
+def read_index(file_path: Path | str) -> ModpackIndex:
+    file_path = Path(file_path)
+
+    pack_index = {}
+    with zipfile.ZipFile(file_path) as zip_file:
+        pack_index = json.loads(zip_file.read("modrinth.index.json").decode())
+
+    files = []
+    for file in pack_index["files"]:
+        files.append(
+            {
+                "file_path": Path(file["path"]),
+                "hashes": file["hashes"],
+                "mod_environment": file.get("env"),
+                "download_urls": file["downloads"],
+                "file_size": file["fileSize"],
+            }
+        )
+
+    return {
+        "format_version": pack_index["formatVersion"],
+        "game_name": pack_index["game"],
+        "version_id": pack_index["versionId"],
+        "pack_name": pack_index["name"],
+        "summary": pack_index.get("summary"),
+        "files": files,
+        "dependencies": pack_index["dependencies"],
+    }
+
+
+def _extract_zip(
+    zip_file: zipfile.ZipFile, zip_path: str, path: Path | str = Path.cwd()
+):
+    path = Path(path)
+    for entry in zip_file.namelist():
+        if not entry.startswith(zip_path):
+            continue
+
+        destination_path = path / entry.removeprefix(zip_path)
+        destination_path.parent.mkdir(parents=True, exist_ok=True)
+
+        if entry.endswith("/"):
+            destination_path.mkdir(exist_ok=True)
+        else:
+            destination_path.write_bytes(zip_file.read(entry))
+
+
+def apply_overrides(file_path: str | Path) -> None:
+    file_path = Path(file_path)
+
+    with zipfile.ZipFile(file_path) as zip_file:
+        _extract_zip(zip_file, "overrides/")
+
+
+def apply_server_overrides(file_path: str | Path) -> None:
+    file_path = Path(file_path)
+
+    with zipfile.ZipFile(file_path) as zip_file:
+        _extract_zip(zip_file, "server-overrides/")

mcserver/modrinth/project_records/relationships.py

@@ -0,0 +1,203 @@
+# Imports
+# Standard
+import json
+import logging as log
+from typing import TypedDict
+
+# MCServer
+from .shared import project_records_dir
+from .shared import DependencyTypes
+
+# Types
+dependency_types: list[str] = ["embedded", "optional", "required", "incompatible"]
+
+
+# TypedDicts
+class ProjectRelationships(TypedDict):
+    dependencies: dict[str, DependencyTypes]
+    dependents: dict[str, DependencyTypes]
+
+
+# Functions
+def create(
+    project_id: str,
+    dependencies: dict[str, DependencyTypes] | None = None,
+    dependents: dict[str, DependencyTypes] | None = None,
+) -> None:
+    """Create a new project relationships record
+
+    Args:
+        project_id: The Modrinth project ID
+        dependencies: List of dependencies and its type
+        dependents: List of dependents and its type
+
+    Raises:
+        FileNotFoundError: When project_records_dir does not exist
+        FileExistError: When project already have a record
+
+    Returns:
+        None
+    """
+    if dependencies is None:
+        dependencies = {}
+
+    if dependents is None:
+        dependents = {}
+
+    if not project_records_dir.exists():
+        raise FileNotFoundError(f"Directory '{project_records_dir}' does not exist")
+
+    project_record_dir = project_records_dir / project_id
+    relationships_file = project_record_dir / "relationships.json"
+    if relationships_file.exists():
+        raise FileExistsError(
+            f"Relationships for project ID '{project_id}' already exists"
+        )
+
+    project_relationships: ProjectRelationships = {"dependencies": {}, "dependents": {}}
+    for dependency_id, dependency_type in dependencies.items():
+        if dependency_type not in dependency_types:
+            log.error(
+                f"Invalid dependency type '{dependency_type}' for dependency ID '{dependency_id}' of project ID '{project_id}', ignoring..."
+            )
+            continue
+
+        project_relationships["dependencies"][dependency_id] = dependency_type
+
+    for dependent_id, dependency_type in dependents.items():
+        if dependency_type not in dependency_types:
+            log.error(
+                f"Invalid dependency type '{dependency_type}' for dependent ID '{dependent_id}' of project ID '{project_id}', ignoring..."
+            )
+            continue
+
+        project_relationships["dependents"][dependent_id] = dependency_type
+
+    relationships_data = json.dumps(project_relationships, indent=2)
+    relationships_file.write_text(relationships_data)
+
+
+def read(project_id: str) -> ProjectRelationships:
+    """Read a project's relationships record
+
+    Args:
+        project_id: The Modrinth project ID
+
+    Raises:
+        FileNotFoundError: Project has no relationships record or project_records_dir does not exist
+        json.JSONDecodeError: Project relationships record file is corrupted
+
+    Returns:
+        List of dependencies and dependents of the project
+    """
+    if not project_records_dir.exists():
+        raise FileNotFoundError(f"Directory '{project_records_dir}' does not exist")
+
+    project_record_dir = project_records_dir / project_id
+    relationships_file = project_record_dir / "relationships.json"
+    project_relationships: ProjectRelationships = {"dependencies": {}, "dependents": {}}
+
+    if not relationships_file.exists():
+        raise FileNotFoundError(
+            f"Relationships file for project ID '{project_id}' does not exist"
+        )
+
+    relationships_data = relationships_file.read_text()
+    relationships_json: ProjectRelationships = {"dependencies": {}, "dependents": {}}
+
+    try:
+        relationships_json = json.loads(relationships_data)
+    except json.JSONDecodeError as error:
+        raise error
+
+    dependencies = relationships_json["dependencies"]
+    dependents = relationships_json["dependents"]
+
+    for dependency_id, dependency_type in dependencies.items():
+        if dependency_type not in dependency_types:
+            log.error(
+                f"Invalid type '{dependency_type}' for dependency ID '{dependency_id}' of project ID '{project_id}', ignoring..."
+            )
+            continue
+
+        project_relationships["dependencies"][dependency_id] = dependency_type
+
+    for dependent_id, dependent_type in dependents.items():
+        if dependent_type not in dependency_types:
+            log.error(
+                f"Invalid type '{dependent_type}' for dependent ID '{dependent_id}' of project ID '{project_id}', ignoring..."
+            )
+            continue
+
+        project_relationships["dependents"][dependent_id] = dependent_type
+
+    return project_relationships
+
+
+def update(
+    project_id: str,
+    new_dependencies: dict[str, DependencyTypes] | None = None,
+    new_dependents: dict[str, DependencyTypes] | None = None,
+) -> None:
+    """Update an existing project relationships record
+
+    Args:
+        project_id: The Modrinth project ID
+        new_dependencies: New dependencies relationships data
+        new_dependents: New dependents relationships data
+
+    Raises:
+        FileNotFoundError: Project has no relationships record or project_records_dir does not exist
+        json.JSONDecodeError: Project relationships record file is corrupted
+    """
+    if new_dependencies is None:
+        new_dependencies = {}
+
+    if new_dependents is None:
+        new_dependents = {}
+
+    if not project_records_dir.exists():
+        raise FileNotFoundError(f"Directory '{project_records_dir}' does not exist")
+
+    project_record_dir = project_records_dir / project_id
+    relationships_file = project_record_dir / "relationships.json"
+    if not relationships_file.exists():
+        raise FileNotFoundError(
+            f"Relationships file for project ID '{project_id}' does not exist"
+        )
+
+    project_relationships: ProjectRelationships = {"dependencies": {}, "dependents": {}}
+    relationships_data = relationships_file.read_text()
+
+    try:
+        relationships_json = json.loads(relationships_data)
+    except json.JSONDecodeError as error:
+        raise error
+
+    project_relationships.update(relationships_json)
+    relationships_data = json.dumps(project_relationships, indent=2)
+    relationships_file.write_text(relationships_data)
+
+
+def delete(project_id: str):
+    """ "Delete a project's relationships record
+
+    Args:
+        project_id: The Modrinth project ID
+
+    Raises:
+        FileNotFoundError: Project has no relationships record or project_records_dir does not exist
+    """
+    if not project_records_dir.exists():
+        raise FileNotFoundError(
+            f"Relationships file for project ID '{project_id}' does not exist"
+        )
+
+    project_record_dir = project_records_dir / project_id
+    relationships_file = project_record_dir / "relationships.json"
+    if not relationships_file.exists():
+        raise FileNotFoundError(
+            f"Relationships file for project ID '{project_id}' does not exist"
+        )
+
+    relationships_file.unlink()

mcserver/modrinth/project_records/shared.py

@@ -0,0 +1,9 @@
+# Imports
+# Standard
+from pathlib import Path
+
+# MCServer
+from ..shared import modrinth_dir
+from ..shared import DependencyTypes
+
+project_records_dir: Path = modrinth_dir / "project_records"

mcserver/modrinth/projects.py

@@ -0,0 +1,80 @@
+# Modules
+# Standard
+import json
+
+from ..shared import merge_dict
+
+# MCServer
+from .shared import modrinth_dir
+
+# Paths
+projects_dir = modrinth_dir / "projects"
+
+
+# Functions
+def create_project_entry(
+    project_id: str, metadata: dict | None = None, relationship: dict | None = None
+) -> None:
+    if metadata is None:
+        metadata = {}
+    if relationship is None:
+        relationship = {}
+
+    project_entry = projects_dir / project_id
+    project_metadata = project_entry / "metadata.json"
+    project_relationship = project_entry / "relationship.json"
+
+    if project_entry.exists():
+        raise FileExistsError(f"Project index for '{project_id}' already exists")
+
+    project_entry.mkdir(parents=True)
+    project_metadata.write_text(json.dumps(metadata, indent=2))
+    project_relationship.write_text(json.dumps(relationship, indent=2))
+
+
+def read_project_entry(project_id: str) -> dict:
+    project_index = projects_dir / project_id
+    project_metadata = project_index / "metadata.json"
+    project_relationship = project_index / "relationship.json"
+
+    return {
+        "metadata": json.loads(project_metadata.read_text()),
+        "relationship": json.loads(project_relationship.read_text()),
+    }
+
+
+def update_project_entry(
+    project_id: str,
+    new_metadata: dict | None = None,
+    new_relationship: dict | None = None,
+) -> None:
+    if new_metadata is None:
+        new_metadata = {}
+    if new_relationship is None:
+        new_relationship = {}
+
+    project_index = projects_dir / project_id
+    project_metadata = project_index / "metadata.json"
+    project_relationship = project_index / "relationship.json"
+
+    old_data = read_project_entry(project_id)
+    project_metadata.write_text(
+        json.dumps(merge_dict(old_data["metadata"], new_metadata), indent=2)
+    )
+    project_relationship.write_text(
+        json.dumps(merge_dict(old_data["relationship"], new_relationship), indent=2)
+    )
+
+
+def delete_project_entry(project_id: str) -> None:
+    project_index = projects_dir / project_id
+    project_metadata = project_index / "metadata.json"
+    project_relationship = project_index / "relationship.json"
+
+    project_metadata.unlink()
+    project_relationship.unlink()
+    project_index.rmdir()
+
+
+def project_entry_exists(project_id: str) -> bool:
+    return (projects_dir / project_id).exists()

mcserver/modrinth/shared.py

@@ -0,0 +1,13 @@
+# Modules
+# Standard
+from pathlib import Path
+from typing import Literal, TypeAlias
+
+# MCServer
+from ..shared import mcserver_dir
+
+# TypeAliases
+DependencyTypes: TypeAlias = Literal["embedded", "optional", "required", "incompatible"]
+
+# Variables
+modrinth_dir: Path = mcserver_dir / "modrinth"

mcserver/modrinth/slug_index.py

@@ -0,0 +1,36 @@
+# Modules
+# Standard
+import json
+
+# MCServer
+from .shared import modrinth_dir
+
+# Variables
+_slug_index = None
+
+# Paths
+slug_index_file = modrinth_dir / "slug_index.json"
+
+
+# Functions
+def _load_slug_index() -> None:
+    global _slug_index
+    if _slug_index is None:
+        _slug_index = json.loads(slug_index_file.read_text())
+
+
+def slug_to_id(project_slug: str) -> str:
+    _load_slug_index()
+    project_id: str = ""
+    if _slug_index is not None:
+        project_id = _slug_index.get(project_slug, project_slug)["id"]
+
+    return project_id
+
+
+def add_slug(project_slug: str, project_id: str) -> None:
+    global _slug_index
+    if _slug_index is None:
+        _slug_index = {}
+
+    _slug_index[project_slug] = project_id

mcserver/mojang/eula.py

@@ -0,0 +1,28 @@
+# Modules
+# Standard
+import time
+from pathlib import Path
+
+# Paths
+eula_file = Path("eula.txt")
+
+
+# Functions
+def is_eula_agreed() -> bool:
+    try:
+        for line in eula_file.read_text().split("\n"):
+            if line.startswith("eula=true"):
+                return True
+    except FileNotFoundError:
+        pass
+
+    return False
+
+
+def eula_agree() -> None:
+    timestamp = time.strftime("%a %b %d %H:%M:%S GMT %Y", time.gmtime())
+    eula_file.write_text(
+        f"""#By changing the setting below to TRUE you are indicating your agreement to our EULA (https://aka.ms/MinecraftEULA).
+#{timestamp}
+eula=true"""
+    )

mcserver/mojang/manifest.py

@@ -0,0 +1,69 @@
+# Modules
+# Standard
+import json
+from typing import TypedDict
+
+# MCServer
+from .. import networking
+from ..constants import mojang_manifest_url
+
+
+# TypedDict
+class LatestVersion(TypedDict):
+    release_version: str  # original: release
+    snapshot_version: str  # original: snapshot
+
+
+class GameVersion(TypedDict):
+    version_id: str  # original: id
+    version_type: str  # original: type
+    package_url: str  # original: url
+    release_time: str  # original: releaseTime
+    package_sha1: str  # original: sha1
+    compliance_level: int  # original: complianceLevel
+
+
+class VersionManifest(TypedDict):
+    latest_game_version: LatestVersion  # original: latest
+    game_versions: list[GameVersion]  # original: versions
+
+
+# Functions
+def get_version_manifest() -> VersionManifest:
+    response = networking.request(
+        f"{mojang_manifest_url}/mc/game/version_manifest_v2.json"
+    )
+    response_json = json.loads(response["text"])
+
+    latest_version = response_json["latest"]
+
+    game_versions: list[GameVersion] = []
+    for version in response_json["versions"]:
+        game_version: GameVersion = {
+            "version_id": version["id"],
+            "version_type": version["type"],
+            "release_time": version["releaseTime"],
+            "package_url": version["url"],
+            "package_sha1": version["sha1"],
+            "compliance_level": version["complianceLevel"],
+        }
+
+        game_versions.append(game_version)
+
+    version_manifest: VersionManifest = {
+        "latest_game_version": {
+            "release_version": latest_version["release"],
+            "snapshot_version": latest_version["snapshot"],
+        },
+        "game_versions": game_versions,
+    }
+
+    return version_manifest
+
+
+def get_latest_release_version() -> str:
+    return get_version_manifest()["latest_game_version"]["release_version"]
+
+
+def get_latest_snapshot_version() -> str:
+    return get_version_manifest()["latest_game_version"]["snapshot_version"]

mcserver/mysterious.py

@@ -0,0 +1,5 @@
+def nothing_to_see_here_move_along():
+    import sys
+
+    print("The cake is a lie.")
+    sys.exit(127)