mcserver-cli 3.0.0__py3-none-any.whl

mcserver/server_files/banned_players.py

@@ -0,0 +1,166 @@
+# Modules
+# Standard
+import json
+import logging as log
+from pathlib import Path
+from typing import Literal, TypedDict
+from uuid import UUID
+
+# MCServer
+from mcserver.minecraft.player_identity import (
+    PlayerID,
+    PlayerUUID,
+    normalize_player_uuid,
+)
+
+# Paths
+banned_players_file = Path("banned-players.json")
+
+
+# TypedDicts
+class BannedPlayerEntry(TypedDict):
+    uuid: str
+    name: str
+    created: str  # Time Format: yyyy-MM-dd HH:mm:ss Z
+    source: str
+    expires: str | Literal["forever"]  # Time format: yyyy-MM-dd HH:mm:ss Z
+    reason: str
+
+
+class BannedPlayer(TypedDict):
+    player_uuid: PlayerUUID
+    player_name: str
+    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 Players
+def add_player(
+    player_uuid: PlayerUUID,
+    player_name: str,
+    created_time: str,
+    ban_source: str,
+    expires_time: str | Literal["forever"] = "forever",
+    ban_reason: str = "Banned via MCServer.",
+) -> None:
+    player_uuid = normalize_player_uuid(player_uuid)
+    banned_player: BannedPlayer = {
+        "player_uuid": player_uuid,
+        "player_name": player_name,
+        "created_time": created_time,
+        "ban_source": ban_source,
+        "expires_time": expires_time,
+        "ban_reason": ban_reason,
+    }
+
+    add_players(banned_player)
+
+
+def add_players(banned_players: list[BannedPlayer] | BannedPlayer) -> None:
+    if not isinstance(banned_players, list):
+        banned_players = [banned_players]
+
+    with open(banned_players_file, mode="r+") as file:
+        banned_players_data = json.load(file)
+        for player in banned_players:
+            player_uuid = str(normalize_player_uuid(player["player_uuid"]))
+            player_name = player["player_name"]
+            ban_reason = player["ban_reason"]
+
+            banned_player_entry: BannedPlayerEntry = {
+                "uuid": player_uuid,
+                "name": player_name,
+                "created": player["created_time"],
+                "source": player["ban_source"],
+                "expires": player["expires_time"],
+                "reason": ban_reason,
+            }
+
+            banned_players_data.append(banned_player_entry)
+            log.debug(
+                f"Added player '{player_name}' ({player_uuid}) to the banned player list with reason '{ban_reason}'"
+            )
+
+        file.seek(0)
+        json.dump(banned_players_data, file, indent=2)
+        file.truncate()
+
+
+# Remove Players
+def remove_player(
+    player_uuid: PlayerUUID | None = None, player_name: str | None = None
+) -> None:
+    if player_uuid is None and player_name is None:
+        raise ValueError(
+            "At least one of 'player_uuid' or 'player_name' must be provided"
+        )
+
+    player_id: PlayerID = {}
+    if player_uuid is not None:
+        player_uuid = normalize_player_uuid(player_uuid)
+        player_id["player_uuid"] = normalize_player_uuid(player_uuid)
+
+    if player_name is not None:
+        player_id["player_name"] = player_name
+
+    remove_players(player_id)
+
+
+def remove_players(player_ids: list[PlayerID] | PlayerID) -> None:
+    if not isinstance(player_ids, list):
+        player_ids = [player_ids]
+
+    player_uuids: set[PlayerUUID | None] = set()
+    player_names: set[str | None] = set()
+    for player_id in player_ids:
+        if "player_uuid" in player_id:
+            player_uuids.add(player_id["player_uuid"])
+
+        if "player_name" in player_id:
+            player_names.add(player_id["player_name"])
+
+    with open(banned_players_file, mode="r+") as file:
+        banned_players_data: list[BannedPlayerEntry] = json.load(file)
+        new_banned_players_data: list[BannedPlayerEntry] = []
+        for player in banned_players_data:
+            player_uuid = player["uuid"]
+            player_name = player["name"]
+
+            if player_uuid in player_uuids or player_name in player_names:
+                log.debug(
+                    f"Removed player '{player_name}' ({player_uuid}) from the banned player list"
+                )
+                continue
+
+            new_banned_players_data.append(player)
+
+        file.seek(0)
+        json.dump(new_banned_players_data, file, indent=2)
+        file.truncate()
+
+
+# TODO: add 'update_player' and 'update_players', just use plain dict.update() because it has no depth
+
+
+# List Players
+def list_players() -> list[BannedPlayer]:
+    banned_players_data: list[BannedPlayerEntry] = json.loads(
+        banned_players_file.read_text()
+    )
+    banned_players: list[BannedPlayer] = []
+    for entry in banned_players_data:
+        banned_player: BannedPlayer = {
+            "player_uuid": UUID(entry["uuid"]),
+            "player_name": entry["name"],
+            "created_time": entry["created"],
+            "ban_source": entry["source"],
+            "expires_time": entry["expires"],
+            "ban_reason": entry["reason"],
+        }
+
+        banned_players.append(banned_player)
+
+    return banned_players

mcserver/server_files/ops.py

@@ -0,0 +1,143 @@
+# Modules
+# Standard
+import json
+from pathlib import Path
+from typing import Literal, TypedDict
+from uuid import UUID
+
+# MCServer
+from mcserver.minecraft.player_identity import (
+    PlayerID,
+    PlayerUUID,
+    normalize_player_uuid,
+)
+
+# Paths
+ops_file = Path("ops.json")
+
+
+# TypedDicts
+class OperatorEntry(TypedDict):
+    uuid: str
+    name: str
+    level: Literal[0, 1, 2, 3, 4]
+    bypassesPlayerLimit: bool
+
+
+class OperatorPlayer(TypedDict):
+    player_uuid: PlayerUUID
+    player_name: str
+    permission_level: Literal[0, 1, 2, 3, 4]
+    bypasses_player_limit: bool
+
+
+# Functions
+# Add Players
+def add_player(
+    player_uuid: PlayerUUID,
+    player_name: str,
+    permission_level: Literal[0, 1, 2, 3, 4],
+    bypasses_player_limit: bool = False,
+) -> None:
+    operator_player: OperatorPlayer = {
+        "player_uuid": player_uuid,
+        "player_name": player_name,
+        "permission_level": permission_level,
+        "bypasses_player_limit": bypasses_player_limit,
+    }
+
+    add_players(operator_player)
+
+
+def add_players(operator_players: list[OperatorPlayer] | OperatorPlayer) -> None:
+    if not isinstance(operator_players, list):
+        operator_players = [operator_players]
+
+    with open(ops_file, mode="r+") as file:
+        ops_data: list[OperatorEntry] = json.load(file)
+
+        for player in operator_players:
+            permission_level = player["permission_level"]
+            if permission_level < 0 or permission_level > 4:
+                raise ValueError("Permission level must be between 0 and 4.")
+
+            operator_entry: OperatorEntry = {
+                "uuid": str(normalize_player_uuid(player["player_uuid"])),
+                "name": player["player_name"],
+                "level": permission_level,
+                "bypassesPlayerLimit": player["bypasses_player_limit"],
+            }
+
+            ops_data.append(operator_entry)
+
+        file.seek(0)
+        json.dump(ops_data, file, indent=2)
+        file.truncate()
+
+
+# Remove Players
+def remove_player(
+    player_uuid: PlayerUUID | None = None, player_name: str | None = None
+) -> None:
+    if player_uuid is None and player_name is None:
+        raise ValueError(
+            "At least one of 'player_uuid' or 'player_name' must be provided"
+        )
+
+    player_id: PlayerID = {}
+    if player_uuid is not None:
+        player_id["player_uuid"] = normalize_player_uuid(player_uuid)
+
+    if player_name is not None:
+        player_id["player_name"] = player_name
+
+    remove_players(player_id)
+
+
+def remove_players(player_ids: list[PlayerID] | PlayerID) -> None:
+    if not isinstance(player_ids, list):
+        player_ids = [player_ids]
+
+    player_uuids: set[PlayerUUID | None] = set()
+    player_names: set[str | None] = set()
+
+    for player_id in player_ids:
+        if "player_uuid" in player_id:
+            player_uuids.add(player_id["player_uuid"])
+
+        if "player_name" in player_id:
+            player_names.add(player_id["player_name"])
+
+    with open(ops_file, mode="r+") as file:
+        ops_data: list[OperatorEntry] = json.load(file)
+
+        new_ops_data: list[OperatorEntry] = []
+        for player in ops_data:
+            if player["uuid"] in player_uuids or player["name"] in player_names:
+                continue
+
+            new_ops_data.append(player)
+
+        file.seek(0)
+        json.dump(new_ops_data, file, indent=2)
+        file.truncate()
+
+
+# TODO: add 'update_player' and 'update_players', just use plain dict.update() because it has no depth
+
+
+# List Players
+def list_players() -> list[OperatorPlayer]:
+    ops_data: list[OperatorEntry] = json.loads(ops_file.read_text())
+    operator_players: list[OperatorPlayer] = []
+    for entry in ops_data:
+        operator_player: OperatorPlayer = {
+            "player_uuid": UUID(entry["uuid"]),
+            "player_name": entry["name"],
+            "permission_level": entry["level"],
+            "bypasses_player_limit": entry["bypassesPlayerLimit"],
+        }
+
+        operator_players.append(operator_player)
+
+    return operator_players

mcserver/server_files/properties.py

@@ -0,0 +1,41 @@
+# Imports
+from typing import TypedDict
+
+
+# TypedDicts
+class ParsedProperties(TypedDict):
+    comments: list[str]
+    data: dict[str, str]
+
+
+# Functions
+def loads(properties_data: str) -> ParsedProperties:
+    parsed_properties: ParsedProperties = {"comments": [], "data": {}}
+
+    for line in properties_data.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+
+        if line.startswith("#"):
+            parsed_properties["comments"].append(line)
+
+        if not "=" in line:
+            continue
+
+        key, value = line.split("=", 1)
+        parsed_properties[key.strip()] = value
+
+    return parsed_properties
+
+
+# Dump only support comments that are oon top of the file
+def dumps(parsed_properties: ParsedProperties) -> str:
+    lines: list[str] = []
+    for comment in parsed_properties["comments"]:
+        lines.append(f"#{comment}")
+
+    for key, value in parsed_properties["data"].items():
+        lines.append(f"{key}={value}")
+
+    return "\n".join(lines)

mcserver/server_files/whitelist.py

@@ -0,0 +1,163 @@
+# Modules
+# Standard
+import json
+import logging as log
+from pathlib import Path
+from typing import TypedDict
+from uuid import UUID
+
+# MCServer
+from mcserver.minecraft.player_identity import (
+    PlayerID,
+    PlayerUUID,
+    normalize_player_uuid,
+)
+
+# Paths
+whitelist_file = Path("whitelist.json")
+
+
+# TypedDicts
+class WhitelistEntry(TypedDict):
+    uuid: str
+    name: str
+
+
+class WhitelistPlayer(TypedDict):
+    player_uuid: PlayerUUID
+    player_name: str
+
+
+# Functions
+# Add Players
+def add_player(player_uuid: PlayerUUID, player_name: str) -> None:
+    whitelist_player: WhitelistPlayer = {
+        "player_uuid": player_uuid,
+        "player_name": player_name,
+    }
+
+    add_players(whitelist_player)
+
+
+def add_players(whitelist_players: list[WhitelistPlayer] | WhitelistPlayer) -> None:
+    if not isinstance(whitelist_players, list):
+        whitelist_players = [whitelist_players]
+
+    with open(whitelist_file, mode="r+") as file:
+        whitelist_data = json.load(file)
+
+        for player in whitelist_players:
+            whitelist_entry: WhitelistEntry = {
+                "uuid": str(normalize_player_uuid(player["player_uuid"])),
+                "name": player.get("player_name", ""),
+            }
+
+            whitelist_data.append(whitelist_entry)
+
+        file.seek(0)
+        json.dump(whitelist_data, file, indent=2)
+        file.truncate()
+
+
+# Remove Players
+def remove_player(
+    player_uuid: PlayerUUID | None = None, player_name: str | None = None
+) -> None:
+    if player_uuid is None and player_name is None:
+        raise ValueError(
+            "At least one of 'player_uuid' or 'player_name' must be provided"
+        )
+
+    player_id: PlayerID = {}
+    if player_uuid is not None:
+        player_uuid = normalize_player_uuid(player_uuid)
+        player_id["player_uuid"] = normalize_player_uuid(player_uuid)
+
+    if player_name is not None:
+        player_id["player_name"] = player_name
+
+    remove_players(player_id)
+
+
+def remove_players(player_ids: list[PlayerID] | PlayerID) -> None:
+    """Remove player entries matching the exact UUIDs or names
+
+    Args:
+        player_ids: Player UUIDs and/or names object
+
+    Returns:
+        None: Returns nothing
+
+    Raises:
+        FileNotFoundError: The 'whitelist.json' file not found
+    """
+    if not isinstance(player_ids, list):
+        player_ids = [player_ids]
+
+    player_uuids: set[PlayerUUID | None] = set()
+    player_names: set[str | None] = set()
+    for player_id in player_ids:
+        if "player_uuid" in player_id:
+            player_uuids.add(player_id["player_uuid"])
+
+        if "player_name" in player_id:
+            player_names.add(player_id["player_name"])
+
+    if not whitelist_file.exists():
+        raise FileNotFoundError(f"File '{whitelist_file}' is not found.")
+
+    with open(whitelist_file, mode="r+") as file:
+        whitelist_data: list[WhitelistEntry] = json.load(file)
+        new_whitelist_data: list[WhitelistEntry] = []
+        for player in whitelist_data:
+            player_uuid = player["uuid"]
+            player_name = player["name"]
+
+            if player_uuid in player_uuids or player_name in player_names:
+                log.debug(
+                    f"Removed player '{player_name}' ({player_uuid}) from the whitelisted player list"
+                )
+                continue
+
+            new_whitelist_data.append(player)
+
+        file.seek(0)
+        json.dump(new_whitelist_data, file, indent=2)
+        file.truncate()
+
+
+# TODO: add 'update_player' and 'update_players', just use plain dict.update() because it has no depth
+
+
+# List Players
+def list_players() -> list[WhitelistPlayer]:
+    whitelist_data: list[WhitelistEntry] = json.loads(whitelist_file.read_text())
+
+    whitelist_players: list[WhitelistPlayer] = []
+    for entry in whitelist_data:
+        player_uuid: str | None = entry.get("uuid", None)
+        player_name: str | None = entry.get("name", None)
+
+        if player_uuid is None or player_name is None:
+            error_message = f"Invalid whitelist entry!"
+            if player_uuid:
+                error_message += f" UUID: '{player_uuid}'"
+
+            if player_name:
+                error_message += f" Name: '{player_name}'"
+
+            log.error(error_message)
+            continue
+
+        try:
+            whitelist_player: WhitelistPlayer = {
+                "player_uuid": UUID(player_uuid),
+                "player_name": entry["name"],
+            }
+        except ValueError:
+            log.error(f"Invalid UUID in whitelist: '{player_uuid}'")
+            continue
+
+        whitelist_players.append(whitelist_player)
+
+    return whitelist_players