mcserver-cli 3.0.0__py3-none-any.whl

mcserver/networking.py

@@ -0,0 +1,152 @@
+# Modules
+# Standard
+import hashlib
+import logging as log
+import shutil
+import urllib.parse
+import urllib.request
+from pathlib import Path
+from typing import TypedDict
+
+# MCServer
+from . import __version__
+from .shared import current_dir, format_number, mcserver_dir, print_status
+
+
+# TypedDict
+class ResponseObject(TypedDict):
+    text: str
+    headers: dict
+    status: int
+
+
+# Errors
+class DownloadURLError(Exception):
+    pass
+
+
+# Variables
+user_agent = f"Othecat35/MCServer/{__version__} (https://github.com/Othecat35/MCServer)"
+read_chunk_size: int = 1024 * 64  # 64KiB
+
+# Paths
+tempfiles_dir = mcserver_dir / "tempfiles"
+
+
+# Functions
+def request(
+    url: str,
+    query: dict | None = None,
+    data: bytes | None = None,
+    headers: dict | None = None,
+    method: str = "GET",
+    timeout: int = 10,
+) -> ResponseObject:
+    method = method.upper()
+    if query is None:
+        query = {}
+    if headers is None:
+        headers = {}
+    headers.setdefault("User-Agent", user_agent)
+
+    query_string = f"?{urllib.parse.urlencode(query)}" if query else ""
+    request = urllib.request.Request(
+        f"{url}{query_string}", data=data, headers=headers, method=method
+    )
+
+    log.debug(f"Requesting URL: {method} {request.full_url}")
+    with urllib.request.urlopen(request, timeout=timeout) as response:
+        log.debug(f"Responded with status: {response.status} {response.reason}")
+
+        response_headers = {}
+        for key, value in response.getheaders():
+            response_headers[key.lower()] = value
+
+        return {
+            "text": response.read().decode("utf-8"),
+            "headers": response_headers,
+            "status": response.status,
+        }
+
+
+def download(
+    url: str,
+    filename: str | Path,
+    hashes: dict | None = None,
+    headers: dict | None = None,
+    timeout: int = 10,
+):
+    filename = Path(filename)
+    if hashes is None:
+        hashes = {}
+    if headers is None:
+        headers = {}
+    headers.setdefault("User-Agent", user_agent)
+
+    basename = filename.name
+    tempfile = tempfiles_dir / basename
+
+    request_url = urllib.request.Request(url, headers=headers, method="GET")
+
+    log.debug(f"Downloading URL: {request_url.full_url}")
+    log.debug(f"Temporary file: {tempfile}")
+
+    hash_algorithm = None
+    hash_name = None
+
+    if hashes.get("sha512"):
+        hash_algorithm = hashlib.sha512()
+        hash_name = "sha512"
+    elif hashes.get("sha1"):
+        hash_algorithm = hashlib.sha1()
+        hash_name = "sha1"
+    elif hashes.get("md5"):
+        hash_algorithm = hashlib.md5()
+        hash_name = "md5"
+
+    expected_hash = None
+
+    if hash_name:
+        expected_hash = hashes[hash_name]
+        log.debug(f"Calculating hash {hash_name} while downloading...")
+        log.debug(f"Expected {hash_name}: {expected_hash}")
+
+    with urllib.request.urlopen(request_url, timeout=timeout) as response:
+        content_length = int(response.getheader("Content-Length", default=0))
+        downloaded_length = 0
+
+        with open(tempfile, mode="wb") as file:
+            while True:
+                data = response.read(read_chunk_size)
+
+                if not data:
+                    break
+
+                if hash_algorithm:
+                    hash_algorithm.update(data)
+
+                downloaded_length += len(data)
+
+                if content_length == 0:
+                    print_status(
+                        f"Downloading {basename}... (unknown final size)",
+                        dynamic=f"Downloading {basename}... {format_number(downloaded_length, 'iec')}",
+                    )
+                else:
+                    print_status(
+                        f"Downloading {basename}... File size: {format_number(content_length, 'iec')}",
+                        dynamic=f"Downloading {basename}... {format_number(downloaded_length, 'iec')}/{format_number(content_length, 'iec')} ({round(downloaded_length / content_length * 100)}%)",
+                    )
+
+                file.write(data)
+
+        if hash_algorithm:
+            calculated_hash = hash_algorithm.hexdigest()
+
+            log.debug(f"Got hash: {calculated_hash}")
+            if calculated_hash != expected_hash:
+                raise DownloadURLError(
+                    f"Downloaded file '{tempfile.relative_to(current_dir)}' hash does not match with the expected {hash_name} hash"
+                )
+
+    shutil.move(tempfile, filename)

mcserver/papermc/api.py

@@ -0,0 +1,81 @@
+# Modules
+# Standard
+import json
+from typing import Literal, TypedDict
+
+# MCServer
+from .. import networking
+from ..constants import papermc_api_url
+
+
+# TypedDicts
+class FileHashes(TypedDict):
+    sha256: str  # original: sha256
+
+
+class BuildProp(TypedDict):
+    file_name: str  # original: name
+    file_hashes: FileHashes  # original: checksums
+    file_size: int  # original: size
+    download_url: str  # original: url
+
+
+class BuildCommit(TypedDict):
+    commit_hash: str  # original: hash
+    commit_time: str  # original: time
+    commit_message: str  # original: message
+
+
+class ProjectBuild(TypedDict):
+    build_id: int  # original: id
+    build_time: str  # original: time
+    channel: str  # original: channel
+    build_commits: list[BuildCommit]  # original: commits
+    download_props: dict[str, BuildProp]  # original: downloads
+
+
+# Functions
+def get_project_build(
+    project_name: str, game_version: str, build_id: int | Literal["latest"] = "latest"
+) -> ProjectBuild:
+    response = networking.request(
+        f"{papermc_api_url}/v3/projects/{project_name}/versions/{game_version}/builds/{build_id}"
+    )
+    response_json = json.loads(response["text"])
+
+    build_commits: list[BuildCommit] = []
+    for commit in response_json["commits"]:
+        build_commit: BuildCommit = {
+            "commit_hash": commit["sha"],
+            "commit_time": commit["time"],
+            "commit_message": commit["message"],
+        }
+
+        build_commits.append(build_commit)
+
+    download_props: dict[str, BuildProp] = {}
+    for prop_name, prop_data in response_json["downloads"].items():
+        download_prop: BuildProp = {
+            "file_name": prop_data["name"],
+            "file_hashes": prop_data["checksums"],
+            "file_size": prop_data["size"],
+            "download_url": prop_data["url"],
+        }
+
+        download_props[prop_name] = download_prop
+
+    # NOTE: probably use the "server:default" prop
+
+    project_build: ProjectBuild = {
+        "build_id": response_json["id"],
+        "build_time": response_json["time"],
+        "channel": response_json["channel"],
+        "build_commits": build_commits,
+        "download_props": download_props,
+    }
+
+    return project_build
+
+
+def get_latest_project_build(project_name: str, game_version: str) -> ProjectBuild:
+    return get_project_build(project_name, game_version, "latest")

mcserver/purpurmc/api.py

@@ -0,0 +1,81 @@
+# Modules
+# Standard
+import json
+from typing import Literal, TypedDict
+
+# MCServer
+from .. import networking
+from ..constants import purpurmc_api_url
+
+
+# TypedDicts
+class BuildCommit(TypedDict):
+    author_name: str  # original: author
+    author_email: str  # original: email
+    commit_message: str  # original: description
+    commit_hash: str  # original: hash
+    commit_time: int  # original: timestamp
+
+
+class ProjectBuild(TypedDict):
+    project_name: str  # original: project
+    game_version: str  # original: version
+    build_id: int  # original: build
+    build_status: str  # original: result
+    build_time: int  # original: timestamp
+    build_duration: int  # original: duration
+    build_commits: list[BuildCommit]  # original: commits
+    metadata: dict  # original: metadata
+    artifact_md5: str  # original: md5
+
+
+# Functions
+def get_project_build(
+    project_name: str, game_version: str, build_version: int | Literal["latest"]
+) -> ProjectBuild:
+    response = networking.request(
+        f"{purpurmc_api_url}/v2/{project_name}/{game_version}/{build_version}"
+    )
+    response_data = json.loads(response["text"])
+
+    build_commits: list[BuildCommit] = []
+    for commit in response_data["commits"]:
+        build_commit: BuildCommit = {
+            "author_name": commit["author"],
+            "author_email": commit["email"],
+            "commit_message": commit["description"],
+            "commit_hash": commit["hash"],
+            "commit_time": commit["timestamp"],
+        }
+
+        build_commits.append(build_commit)
+
+    project_build: ProjectBuild = {
+        "project_name": response_data["project"],
+        "game_version": response_data["version"],
+        "build_id": response_data["build"],
+        "build_status": response_data["result"],
+        "build_time": response_data["timestamp"],
+        "build_duration": response_data["duration"],
+        "build_commits": build_commits,
+        "metadata": response_data["metadata"],
+        "artifact_md5": response_data["md5"],
+    }
+
+    return project_build
+
+
+def get_latest_project_build(project_name: str, game_version: str) -> ProjectBuild:
+    return get_project_build(project_name, game_version, "latest")
+
+
+def download_url(
+    project_name: str, game_version: str, build_version: int | Literal["latest"]
+) -> str:
+    return (
+        f"{purpurmc_api_url}/v2/{project_name}/{game_version}/{build_version}/download"
+    )
+
+
+def latest_download_url(project_name: str, game_version: str) -> str:
+    return download_url(project_name, game_version, "latest")

mcserver/quiltmc/meta.py

@@ -0,0 +1,54 @@
+# Modules
+# Standard
+import json
+from typing import TypedDict
+
+# MCServer
+from .. import networking
+from ..constants import quiltmc_meta_url
+
+
+# TypedDicts
+class Hashes(TypedDict):
+    sha1: str
+    sha256: str
+    sha512: str
+
+
+class LoaderVersion(TypedDict):
+    separator: str  # this is the separator for the loader version
+    build_id: int
+    maven_id: str
+    loader_version: str
+    file_size: int
+    hashes: (
+        Hashes  # what hash is this for? I don't know, please future me figure it out :>
+    )
+
+
+# Functions
+def get_loader_versions() -> list[LoaderVersion]:
+    response = networking.request(f"{quiltmc_meta_url}/v3/versions/loader")
+    response_json = json.loads(response["text"])
+
+    loader_versions: list[LoaderVersion] = []
+    for version in response_json:
+        version_hash = version["hashes"]
+        hashes: Hashes = {
+            "sha1": version_hash["sha1"],
+            "sha256": version_hash["sha256"],
+            "sha512": version_hash["sha512"],
+        }
+
+        loader_version: LoaderVersion = {
+            "separator": version["separator"],
+            "build_id": version["build"],
+            "maven_id": version["maven"],
+            "loader_version": version["version"],
+            "file_size": version["file_size"],
+            "hashes": hashes,
+        }
+
+        loader_versions.append(loader_version)
+
+    return loader_versions

mcserver/resolver.py

@@ -0,0 +1,164 @@
+import logging as log
+from collections import deque
+from collections.abc import Callable
+from typing import Literal, TypedDict, TypeAlias
+
+DependencyType: TypeAlias = Literal["embedded", "optional", "required", "incompatible"]
+dependency_types: dict[DependencyType, int] = {
+    "embedded": 0,
+    "optional": 1,
+    "required": 2,
+    "incompatible": 3,
+}
+dependency_types2: list[DependencyType] = [
+    "embedded",
+    "optional",
+    "required",
+    "incompatible",
+]
+
+
+class Dependency(TypedDict):
+    project_id: str
+    dependency_type: DependencyType
+
+
+class Project(TypedDict):
+    is_manual: bool
+    dependencies: dict[str, int]
+    dependents: dict[str, int]
+
+
+class ProjectData(TypedDict):
+    project_id: str
+    is_manual: bool
+    dependencies: list[Dependency]
+    dependents: list[Dependency]
+
+
+# NOTE: These are just theory, or not?
+def human_to_resolver(dependencies: list[Dependency]) -> dict[str, int]:
+    resolver_dependencies: dict[str, int] = {}
+    for dependency in dependencies:
+        resolver_dependencies[dependency["project_id"]] = dependency_types[
+            dependency["dependency_type"]
+        ]
+
+    return resolver_dependencies
+
+
+def resolver_to_human(dependency_graph: dict[str, Project]) -> list[ProjectData]:
+    projects: list[ProjectData] = []
+    for project_id, project_data in dependency_graph.items():
+        dependencies: list[Dependency] = []
+        for dependency_id, dependency_type in project_data["dependencies"].items():
+            dependency: Dependency = {
+                "project_id": dependency_id,
+                "dependency_type": dependency_types2[dependency_type],
+            }
+
+            dependencies.append(dependency)
+
+        dependents: list[Dependency] = []
+        for dependency_id, dependency_type in project_data["dependents"].items():
+            dependent: Dependency = {
+                "project_id": dependency_id,
+                "dependency_type": dependency_types2[dependency_type],
+            }
+
+            dependents.append(dependent)
+
+        project: ProjectData = {
+            "project_id": project_id,
+            "is_manual": project_data["is_manual"],
+            "dependencies": dependencies,
+            "dependents": dependents,
+        }
+
+        projects.append(project)
+
+    return projects
+
+
+def resolve_dependencies(
+    project_ids: list[str] | str,
+    get_dependencies: Callable[[str], dict[str, int]],
+    should_queue: Callable[[int], bool],
+) -> dict[str, Project]:
+    """Resolve dependency tree using BFS
+
+    Args:
+        project_ids: Projects to start with
+        get_dependencies: Callback that returns a dictionary
+        should_queue: Callback that returns a bool
+
+    Raises:
+        TypeError: Callback 'get_dependency' does not return a dictionary
+    """
+    if isinstance(project_ids, str):
+        project_ids = [project_ids]
+
+    queued_projects: deque[str] = deque()
+    visited_projects: set[str] = set()
+    dependency_graph: dict[str, Project] = {}
+
+    for project_id in project_ids:
+        log.debug(f"Adding project '{project_id}' to the queue")
+        queued_projects.append(project_id)
+        project: Project = {"is_manual": True, "dependencies": {}, "dependents": {}}
+        dependency_graph[project_id] = project
+
+    while queued_projects:
+        project_id = queued_projects.popleft()
+        if project_id in visited_projects:
+            log.debug(f"Project '{project_id}' has already been visited")
+            continue
+
+        dependencies = get_dependencies(project_id)
+        dependency_graph[project_id]["dependencies"] = dependencies
+
+        for dependency_id, dependency_type in dependencies.items():
+            if dependency_id in visited_projects:
+                dependency_graph[dependency_id]["dependents"][
+                    project_id
+                ] = dependency_type
+            else:
+                dependency_graph[dependency_id] = {
+                    "is_manual": False,
+                    "dependencies": {},
+                    "dependents": {project_id: dependency_type},
+                }
+
+                if should_queue(dependency_type):
+                    log.debug(f"Adding dependency '{dependency_id}' to queue")
+                    queued_projects.append(dependency_id)
+
+        visited_projects.add(project_id)
+
+    return dependency_graph
+
+
+def required_only(dependency_type: int) -> bool:
+    return dependency_type == dependency_types["required"]
+
+
+def test_dependencies(project_id: str) -> dict[str, int]:
+    dependencies = {
+        "embeddium": [{"project_id": "sodium", "dependency_type": "incompatible"}],
+        "fabric-api": [],
+        "origins": [{"project_id": "fabric-api", "dependency_type": "required"}],
+        "pehkui": [{"project_id": "fabric-api", "dependency_type": "required"}],
+        "podium": [{"project_id": "sodium", "dependency_type": "required"}],
+        "sodium": [],
+        "thdilos-fox-origin-expanded": [
+            {"project_id": "thdilos-fox-origin", "dependency_type": "required"},
+            {"project_id": "pehkui", "dependency_type": "required"},
+            {"project_id": "origins", "dependency_type": "required"},
+        ],
+        "thdilos-fox-origin": [
+            {"project_id": "pehkui", "dependency_type": "required"},
+            {"project_id": "origins", "dependency_type": "required"},
+        ]
+    }
+
+    return human_to_resolver(dependencies[project_id])

mcserver/server_files/banned_ips.py

@@ -0,0 +1,120 @@
+# Modules
+# Standard
+import json
+import logging as log
+from pathlib import Path
+from typing import Literal, TypedDict
+
+# Paths
+banned_ips_file = Path("banned-ips.json")
+
+
+# TypedDicts
+class BannedIPEntry(TypedDict):
+    ip: str | Literal["<unknown>"]  # IPv4 or IPv6
+    created: str  # Time format: yyyy-MM-dd HH:mm:ss Z
+    source: str
+    expires: Literal["forever"] | str  # Time Format:  yyyy-MM-dd HH:mm:ss Z
+    reason: str
+
+
+class BannedIPRecord(TypedDict):
+    ip_address: str  # IPv4 or IPv6
+    created_time: str  # Time format: yyyy-MM-dd HH:mm:ss Z
+    ban_source: str
+    expires_time: str | Literal["forever"]  # Time format: yyyy-MM-dd HH:mm:ss Z
+    ban_reason: str
+
+
+# Functions
+# Add IPs
+def add_ip(
+    ip_address: str,
+    created_time: str,
+    ban_source: str,
+    expires_time: str | Literal["forever"] = "forever",
+    ban_reason: str = "Banned via MCServer.",
+) -> None:
+    banned_ip_record: BannedIPRecord = {
+        "ip_address": ip_address,
+        "created_time": created_time,
+        "ban_source": ban_source,
+        "expires_time": expires_time,
+        "ban_reason": ban_reason,
+    }
+
+    add_ips(banned_ip_record)
+
+
+def add_ips(banned_ip_records: list[BannedIPRecord] | BannedIPRecord) -> None:
+    if not isinstance(banned_ip_records, list):
+        banned_ip_records = [banned_ip_records]
+
+    with open(banned_ips_file, mode="r+") as file:
+        banned_ips_data = json.load(file)
+        for ip_record in banned_ip_records:
+            banned_ip_entry: BannedIPEntry = {
+                "ip": ip_record["ip_address"],
+                "created": ip_record["created_time"],
+                "source": ip_record["ban_source"],
+                "expires": ip_record["expires_time"],
+                "reason": ip_record["ban_reason"],
+            }
+
+            banned_ips_data.append(banned_ip_entry)
+
+        file.seek(0)
+        json.dump(banned_ips_data, file, indent=2)
+        file.truncate()
+
+
+# Remove IPs
+def remove_ip(ip_address: str) -> None:
+    remove_ips(ip_address)
+
+
+def remove_ips(ip_addresses: list[str] | str) -> None:
+    if not isinstance(ip_addresses, list):
+        ip_addresses = [ip_addresses]
+
+    unbanned_ip_addresses: set[str] = set()
+    for ip_address in ip_addresses:
+        unbanned_ip_addresses.add(ip_address)
+
+    with open(banned_ips_file, mode="r+") as file:
+        banned_ips_data: list[BannedIPEntry] = json.load(file)
+        new_banned_ips_data: list[BannedIPEntry] = []
+        for ip_entry in banned_ips_data:
+            ip_address = ip_entry["ip"]
+            if ip_address in unbanned_ip_addresses:
+                log.debug(
+                    f"Removed IP address '{ip_address}' from the banned IP address list"
+                )
+                continue
+
+            new_banned_ips_data.append(ip_entry)
+
+        file.seek(0)
+        json.dump(new_banned_ips_data, file, indent=2)
+        file.truncate()
+
+
+# TODO: add 'update_ip' and 'update_ips', just use plain dict.update() because it has no depth
+
+
+# List IPs
+def list_ips() -> list[BannedIPRecord]:
+    banned_ip_data: list[BannedIPEntry] = json.loads(banned_ips_file.read_text())
+    banned_ip_records: list[BannedIPRecord] = []
+    for ip_entry in banned_ip_data:
+        banned_ip_record: BannedIPRecord = {
+            "ip_address": ip_entry["ip"],
+            "created_time": ip_entry["created"],
+            "ban_source": ip_entry["source"],
+            "expires_time": ip_entry["expires"],
+            "ban_reason": ip_entry["reason"],
+        }
+
+        banned_ip_records.append(banned_ip_record)
+
+    return banned_ip_records