palworld-restapi 0.7.3__py3-none-any.whl

palworld_restapi/__init__.py

@@ -0,0 +1,21 @@
+from .client import PalworldClient
+from .async_client import AsyncPalworldClient
+from .errors import PalworldApiError
+from .models import (
+    ServerInfo,
+    PlayerInfo,
+    PlayersResponse,
+    ServerSettings,
+    ServerMetrics,
+)
+
+__all__ = [
+    "PalworldClient",
+    "AsyncPalworldClient",
+    "PalworldApiError",
+    "ServerInfo",
+    "PlayerInfo",
+    "PlayersResponse",
+    "ServerSettings",
+    "ServerMetrics",
+]

palworld_restapi/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

palworld_restapi/_core.py

@@ -0,0 +1,33 @@
+from typing import Any
+import httpx
+
+from .errors import PalworldApiError
+
+
+def build_url(base_url: str, path: str) -> str:
+    """Build a full URL for the Palworld API."""
+    base = base_url.rstrip("/")
+    if not base.endswith("/v1/api"):
+        base = f"{base}/v1/api"
+    return f"{base}/{path.lstrip('/')}"
+
+
+def handle_response(response: httpx.Response) -> Any:
+    """
+    Handle the HTTP response, parsing JSON if successful, or raising PalworldApiError.
+    """
+    if response.status_code >= 400:
+        raise PalworldApiError(
+            status_code=response.status_code,
+            method=response.request.method,
+            path=str(response.request.url),
+            response_body=response.text,
+        )
+
+    if not response.content:
+        return None
+
+    try:
+        return response.json()
+    except ValueError:
+        return response.text

palworld_restapi/async_client.py

@@ -0,0 +1,96 @@
+from typing import Any, Self
+import httpx
+
+from ._core import build_url, handle_response
+from .models import ServerInfo, PlayersResponse, ServerSettings, ServerMetrics
+
+
+class AsyncPalworldClient:
+    def __init__(
+        self,
+        base_url: str,
+        password: str,
+        username: str = "admin",
+        timeout: float = 10.0,
+    ) -> None:
+        self.base_url = base_url
+        auth = (username, password)
+        self._client = httpx.AsyncClient(auth=auth, timeout=timeout)
+
+    async def __aenter__(self) -> Self:
+        await self._client.__aenter__()
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        await self._client.__aexit__(exc_type, exc_val, exc_tb)
+
+    async def close(self) -> None:
+        await self._client.aclose()
+
+    async def get_info(self) -> ServerInfo:
+        url = build_url(self.base_url, "info")
+        response = await self._client.get(url)
+        data = handle_response(response)
+        return ServerInfo.from_dict(data)
+
+    async def get_players(self) -> PlayersResponse:
+        url = build_url(self.base_url, "players")
+        response = await self._client.get(url)
+        data = handle_response(response)
+        return PlayersResponse.from_dict(data)
+
+    async def get_settings(self) -> ServerSettings:
+        url = build_url(self.base_url, "settings")
+        response = await self._client.get(url)
+        data = handle_response(response)
+        return ServerSettings.from_dict(data)
+
+    async def get_metrics(self) -> ServerMetrics:
+        url = build_url(self.base_url, "metrics")
+        response = await self._client.get(url)
+        data = handle_response(response)
+        return ServerMetrics.from_dict(data)
+
+    async def announce(self, message: str) -> None:
+        url = build_url(self.base_url, "announce")
+        response = await self._client.post(url, json={"message": message})
+        handle_response(response)
+
+    async def kick_player(self, userid: str, message: str | None = None) -> None:
+        url = build_url(self.base_url, "kick")
+        payload = {"userid": userid}
+        if message is not None:
+            payload["message"] = message
+        response = await self._client.post(url, json=payload)
+        handle_response(response)
+
+    async def ban_player(self, userid: str, message: str | None = None) -> None:
+        url = build_url(self.base_url, "ban")
+        payload = {"userid": userid}
+        if message is not None:
+            payload["message"] = message
+        response = await self._client.post(url, json=payload)
+        handle_response(response)
+
+    async def unban_player(self, userid: str) -> None:
+        url = build_url(self.base_url, "unban")
+        response = await self._client.post(url, json={"userid": userid})
+        handle_response(response)
+
+    async def save(self) -> None:
+        url = build_url(self.base_url, "save")
+        response = await self._client.post(url)
+        handle_response(response)
+
+    async def shutdown(self, waittime: int, message: str | None = None) -> None:
+        url = build_url(self.base_url, "shutdown")
+        payload: dict[str, Any] = {"waittime": waittime}
+        if message is not None:
+            payload["message"] = message
+        response = await self._client.post(url, json=payload)
+        handle_response(response)
+
+    async def stop(self) -> None:
+        url = build_url(self.base_url, "stop")
+        response = await self._client.post(url)
+        handle_response(response)

palworld_restapi/cli.py

@@ -0,0 +1,123 @@
+import argparse
+import json
+import os
+import sys
+from typing import Any
+from dataclasses import asdict
+
+from dotenv import load_dotenv
+
+from .client import PalworldClient
+from .errors import PalworldApiError
+
+
+def print_json(obj: Any) -> None:
+    print(json.dumps(obj, indent=2, default=str))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Palworld REST API CLI")
+    parser.add_argument("--env", type=str, help="Path to .env file", default=".env")
+    parser.add_argument("--base-url", type=str, help="Base URL for Palworld API")
+    parser.add_argument(
+        "--username", type=str, help="Username for Basic Auth", default="admin"
+    )
+    parser.add_argument("--password", type=str, help="Password for Basic Auth")
+    parser.add_argument(
+        "--timeout", type=float, help="Request timeout in seconds", default=10.0
+    )
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    subparsers.add_parser("info", help="Get server info")
+    subparsers.add_parser("players", help="Get player list")
+    subparsers.add_parser("settings", help="Get server settings")
+    subparsers.add_parser("metrics", help="Get server metrics")
+
+    announce_parser = subparsers.add_parser(
+        "announce", help="Announce a message to the server"
+    )
+    announce_parser.add_argument("message", type=str, help="Message to announce")
+
+    kick_parser = subparsers.add_parser("kick", help="Kick a player")
+    kick_parser.add_argument("userid", type=str, help="User ID to kick")
+    kick_parser.add_argument("--message", type=str, help="Kick message")
+
+    ban_parser = subparsers.add_parser("ban", help="Ban a player")
+    ban_parser.add_argument("userid", type=str, help="User ID to ban")
+    ban_parser.add_argument("--message", type=str, help="Ban message")
+
+    unban_parser = subparsers.add_parser("unban", help="Unban a player")
+    unban_parser.add_argument("userid", type=str, help="User ID to unban")
+
+    subparsers.add_parser("save", help="Save the world state")
+
+    shutdown_parser = subparsers.add_parser("shutdown", help="Shutdown the server")
+    shutdown_parser.add_argument("waittime", type=int, help="Wait time in seconds")
+    shutdown_parser.add_argument("--message", type=str, help="Shutdown message")
+
+    subparsers.add_parser("stop", help="Stop the server immediately")
+
+    args = parser.parse_args()
+
+    # Load environment variables
+    if os.path.exists(args.env):
+        load_dotenv(args.env)
+
+    base_url = args.base_url or os.environ.get(
+        "PALWORLD_BASE_URL", "http://127.0.0.1:8212"
+    )
+    username = os.environ.get("PALWORLD_USERNAME", args.username)
+    password = args.password or os.environ.get("PALWORLD_PASSWORD")
+    timeout = float(os.environ.get("PALWORLD_TIMEOUT", args.timeout))
+
+    if not password:
+        print(
+            "Error: Password is required. Set it via --password or PALWORLD_PASSWORD.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    try:
+        with PalworldClient(
+            base_url, password=password, username=username, timeout=timeout
+        ) as client:
+            if args.command == "info":
+                print_json(asdict(client.get_info()))
+            elif args.command == "players":
+                print_json(asdict(client.get_players()))
+            elif args.command == "settings":
+                print_json(asdict(client.get_settings()))
+            elif args.command == "metrics":
+                print_json(asdict(client.get_metrics()))
+            elif args.command == "announce":
+                client.announce(args.message)
+                print("Announcement sent successfully.")
+            elif args.command == "kick":
+                client.kick_player(args.userid, message=args.message)
+                print(f"Player {args.userid} kicked successfully.")
+            elif args.command == "ban":
+                client.ban_player(args.userid, message=args.message)
+                print(f"Player {args.userid} banned successfully.")
+            elif args.command == "unban":
+                client.unban_player(args.userid)
+                print(f"Player {args.userid} unbanned successfully.")
+            elif args.command == "save":
+                client.save()
+                print("World saved successfully.")
+            elif args.command == "shutdown":
+                client.shutdown(args.waittime, message=args.message)
+                print(f"Shutdown initiated with wait time {args.waittime}s.")
+            elif args.command == "stop":
+                client.stop()
+                print("Server stopped.")
+    except PalworldApiError as e:
+        print(f"API Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

palworld_restapi/client.py

@@ -0,0 +1,96 @@
+from typing import Any, Self
+import httpx
+
+from ._core import build_url, handle_response
+from .models import ServerInfo, PlayersResponse, ServerSettings, ServerMetrics
+
+
+class PalworldClient:
+    def __init__(
+        self,
+        base_url: str,
+        password: str,
+        username: str = "admin",
+        timeout: float = 10.0,
+    ) -> None:
+        self.base_url = base_url
+        auth = (username, password)
+        self._client = httpx.Client(auth=auth, timeout=timeout)
+
+    def __enter__(self) -> Self:
+        self._client.__enter__()
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        self._client.__exit__(exc_type, exc_val, exc_tb)
+
+    def close(self) -> None:
+        self._client.close()
+
+    def get_info(self) -> ServerInfo:
+        url = build_url(self.base_url, "info")
+        response = self._client.get(url)
+        data = handle_response(response)
+        return ServerInfo.from_dict(data)
+
+    def get_players(self) -> PlayersResponse:
+        url = build_url(self.base_url, "players")
+        response = self._client.get(url)
+        data = handle_response(response)
+        return PlayersResponse.from_dict(data)
+
+    def get_settings(self) -> ServerSettings:
+        url = build_url(self.base_url, "settings")
+        response = self._client.get(url)
+        data = handle_response(response)
+        return ServerSettings.from_dict(data)
+
+    def get_metrics(self) -> ServerMetrics:
+        url = build_url(self.base_url, "metrics")
+        response = self._client.get(url)
+        data = handle_response(response)
+        return ServerMetrics.from_dict(data)
+
+    def announce(self, message: str) -> None:
+        url = build_url(self.base_url, "announce")
+        response = self._client.post(url, json={"message": message})
+        handle_response(response)
+
+    def kick_player(self, userid: str, message: str | None = None) -> None:
+        url = build_url(self.base_url, "kick")
+        payload = {"userid": userid}
+        if message is not None:
+            payload["message"] = message
+        response = self._client.post(url, json=payload)
+        handle_response(response)
+
+    def ban_player(self, userid: str, message: str | None = None) -> None:
+        url = build_url(self.base_url, "ban")
+        payload = {"userid": userid}
+        if message is not None:
+            payload["message"] = message
+        response = self._client.post(url, json=payload)
+        handle_response(response)
+
+    def unban_player(self, userid: str) -> None:
+        url = build_url(self.base_url, "unban")
+        response = self._client.post(url, json={"userid": userid})
+        handle_response(response)
+
+    def save(self) -> None:
+        url = build_url(self.base_url, "save")
+        response = self._client.post(url)
+        handle_response(response)
+
+    def shutdown(self, waittime: int, message: str | None = None) -> None:
+        url = build_url(self.base_url, "shutdown")
+        payload: dict[str, Any] = {"waittime": waittime}
+        if message is not None:
+            payload["message"] = message
+        response = self._client.post(url, json=payload)
+        handle_response(response)
+
+    def stop(self) -> None:
+        url = build_url(self.base_url, "stop")
+        response = self._client.post(url)
+        handle_response(response)

palworld_restapi/errors.py

@@ -0,0 +1,13 @@
+class PalworldApiError(Exception):
+    """Exception raised for errors returned by the Palworld REST API."""
+
+    def __init__(
+        self, status_code: int, method: str, path: str, response_body: str
+    ) -> None:
+        self.status_code = status_code
+        self.method = method
+        self.path = path
+        self.response_body = response_body
+        super().__init__(
+            f"Palworld API Error {status_code} on {method} {path}: {response_body}"
+        )

palworld_restapi/models.py

@@ -0,0 +1,253 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(slots=True, frozen=True)
+class ServerInfo:
+    version: str
+    servername: str
+    description: str
+    worldguid: str
+    raw: dict[str, Any] = field(repr=False, hash=False, compare=False)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "ServerInfo":
+        return cls(
+            version=data.get("version", ""),
+            servername=data.get("servername", ""),
+            description=data.get("description", ""),
+            worldguid=data.get("worldguid", ""),
+            raw=data,
+        )
+
+
+@dataclass(slots=True, frozen=True)
+class PlayerInfo:
+    name: str
+    accountName: str
+    playerId: str
+    userId: str
+    ip: str
+    ping: float
+    location_x: float
+    location_y: float
+    level: int
+    building_count: int
+    raw: dict[str, Any] = field(repr=False, hash=False, compare=False)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "PlayerInfo":
+        return cls(
+            name=data.get("name", ""),
+            accountName=data.get("accountName", ""),
+            playerId=data.get("playerId", ""),
+            userId=data.get("userId", ""),
+            ip=data.get("ip", ""),
+            ping=float(data.get("ping", 0.0)),
+            location_x=float(data.get("location_x", 0.0)),
+            location_y=float(data.get("location_y", 0.0)),
+            level=int(data.get("level", 0)),
+            building_count=int(data.get("building_count", 0)),
+            raw=data,
+        )
+
+
+@dataclass(slots=True, frozen=True)
+class PlayersResponse:
+    players: list[PlayerInfo]
+    raw: dict[str, Any] = field(repr=False, hash=False, compare=False)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "PlayersResponse":
+        return cls(
+            players=[PlayerInfo.from_dict(p) for p in data.get("players", [])],
+            raw=data,
+        )
+
+
+@dataclass(slots=True, frozen=True)
+class ServerMetrics:
+    serverfps: int
+    currentplayernum: int
+    serverframetime: float
+    maxplayernum: int
+    uptime: int
+    basecampnum: int
+    days: int
+    raw: dict[str, Any] = field(repr=False, hash=False, compare=False)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "ServerMetrics":
+        return cls(
+            serverfps=int(data.get("serverfps", 0)),
+            currentplayernum=int(data.get("currentplayernum", 0)),
+            serverframetime=float(data.get("serverframetime", 0.0)),
+            maxplayernum=int(data.get("maxplayernum", 0)),
+            uptime=int(data.get("uptime", 0)),
+            basecampnum=int(data.get("basecampnum", 0)),
+            days=int(data.get("days", 0)),
+            raw=data,
+        )
+
+
+@dataclass(slots=True, frozen=True)
+class ServerSettings:
+    Difficulty: str
+    DayTimeSpeedRate: float
+    NightTimeSpeedRate: float
+    ExpRate: float
+    PalCaptureRate: float
+    PalSpawnNumRate: float
+    PalDamageRateAttack: float
+    PalDamageRateDefense: float
+    PlayerDamageRateAttack: float
+    PlayerDamageRateDefense: float
+    PlayerStomachDecreaceRate: float
+    PlayerStaminaDecreaceRate: float
+    PlayerAutoHPRegeneRate: float
+    PlayerAutoHpRegeneRateInSleep: float
+    PalStomachDecreaceRate: float
+    PalStaminaDecreaceRate: float
+    PalAutoHPRegeneRate: float
+    PalAutoHpRegeneRateInSleep: float
+    BuildObjectDamageRate: float
+    BuildObjectDeteriorationDamageRate: float
+    CollectionDropRate: float
+    CollectionObjectHpRate: float
+    CollectionObjectRespawnSpeedRate: float
+    EnemyDropItemRate: float
+    DeathPenalty: str
+    bEnablePlayerToPlayerDamage: bool
+    bEnableFriendlyFire: bool
+    bEnableInvaderEnemy: bool
+    bActiveUNKO: bool
+    bEnableAimAssistPad: bool
+    bEnableAimAssistKeyboard: bool
+    DropItemMaxNum: int
+    DropItemMaxNum_UNKO: int
+    BaseCampMaxNum: int
+    BaseCampWorkerMaxNum: int
+    DropItemAliveMaxHours: float
+    bAutoResetGuildNoOnlinePlayers: bool
+    AutoResetGuildTimeNoOnlinePlayers: float
+    GuildPlayerMaxNum: int
+    PalEggDefaultHatchingTime: float
+    WorkSpeedRate: float
+    bIsMultiplay: bool
+    bIsPvP: bool
+    bCanPickupOtherGuildDeathPenaltyDrop: bool
+    bEnableNonLoginPenalty: bool
+    bEnableFastTravel: bool
+    bIsStartLocationSelectByMap: bool
+    bExistPlayerAfterLogout: bool
+    bEnableDefenseOtherGuildPlayer: bool
+    CoopPlayerMaxNum: int
+    ServerPlayerMaxNum: int
+    ServerName: str
+    ServerDescription: str
+    PublicPort: int
+    PublicIP: str
+    RCONEnabled: bool
+    RCONPort: int
+    Region: str
+    bUseAuth: bool
+    BanListURL: str
+    RESTAPIEnabled: bool
+    RESTAPIPort: int
+    bShowPlayerList: bool
+    AllowConnectPlatform: str
+    bIsUseBackupSaveData: bool
+    LogFormatType: str
+    raw: dict[str, Any] = field(repr=False, hash=False, compare=False)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "ServerSettings":
+        return cls(
+            Difficulty=data.get("Difficulty", ""),
+            DayTimeSpeedRate=float(data.get("DayTimeSpeedRate", 0.0)),
+            NightTimeSpeedRate=float(data.get("NightTimeSpeedRate", 0.0)),
+            ExpRate=float(data.get("ExpRate", 0.0)),
+            PalCaptureRate=float(data.get("PalCaptureRate", 0.0)),
+            PalSpawnNumRate=float(data.get("PalSpawnNumRate", 0.0)),
+            PalDamageRateAttack=float(data.get("PalDamageRateAttack", 0.0)),
+            PalDamageRateDefense=float(data.get("PalDamageRateDefense", 0.0)),
+            PlayerDamageRateAttack=float(data.get("PlayerDamageRateAttack", 0.0)),
+            PlayerDamageRateDefense=float(data.get("PlayerDamageRateDefense", 0.0)),
+            PlayerStomachDecreaceRate=float(data.get("PlayerStomachDecreaceRate", 0.0)),
+            PlayerStaminaDecreaceRate=float(data.get("PlayerStaminaDecreaceRate", 0.0)),
+            PlayerAutoHPRegeneRate=float(data.get("PlayerAutoHPRegeneRate", 0.0)),
+            PlayerAutoHpRegeneRateInSleep=float(
+                data.get("PlayerAutoHpRegeneRateInSleep", 0.0)
+            ),
+            PalStomachDecreaceRate=float(data.get("PalStomachDecreaceRate", 0.0)),
+            PalStaminaDecreaceRate=float(data.get("PalStaminaDecreaceRate", 0.0)),
+            PalAutoHPRegeneRate=float(data.get("PalAutoHPRegeneRate", 0.0)),
+            PalAutoHpRegeneRateInSleep=float(
+                data.get("PalAutoHpRegeneRateInSleep", 0.0)
+            ),
+            BuildObjectDamageRate=float(data.get("BuildObjectDamageRate", 0.0)),
+            BuildObjectDeteriorationDamageRate=float(
+                data.get("BuildObjectDeteriorationDamageRate", 0.0)
+            ),
+            CollectionDropRate=float(data.get("CollectionDropRate", 0.0)),
+            CollectionObjectHpRate=float(data.get("CollectionObjectHpRate", 0.0)),
+            CollectionObjectRespawnSpeedRate=float(
+                data.get("CollectionObjectRespawnSpeedRate", 0.0)
+            ),
+            EnemyDropItemRate=float(data.get("EnemyDropItemRate", 0.0)),
+            DeathPenalty=data.get("DeathPenalty", ""),
+            bEnablePlayerToPlayerDamage=bool(
+                data.get("bEnablePlayerToPlayerDamage", False)
+            ),
+            bEnableFriendlyFire=bool(data.get("bEnableFriendlyFire", False)),
+            bEnableInvaderEnemy=bool(data.get("bEnableInvaderEnemy", False)),
+            bActiveUNKO=bool(data.get("bActiveUNKO", False)),
+            bEnableAimAssistPad=bool(data.get("bEnableAimAssistPad", False)),
+            bEnableAimAssistKeyboard=bool(data.get("bEnableAimAssistKeyboard", False)),
+            DropItemMaxNum=int(data.get("DropItemMaxNum", 0)),
+            DropItemMaxNum_UNKO=int(data.get("DropItemMaxNum_UNKO", 0)),
+            BaseCampMaxNum=int(data.get("BaseCampMaxNum", 0)),
+            BaseCampWorkerMaxNum=int(data.get("BaseCampWorkerMaxNum", 0)),
+            DropItemAliveMaxHours=float(data.get("DropItemAliveMaxHours", 0.0)),
+            bAutoResetGuildNoOnlinePlayers=bool(
+                data.get("bAutoResetGuildNoOnlinePlayers", False)
+            ),
+            AutoResetGuildTimeNoOnlinePlayers=float(
+                data.get("AutoResetGuildTimeNoOnlinePlayers", 0.0)
+            ),
+            GuildPlayerMaxNum=int(data.get("GuildPlayerMaxNum", 0)),
+            PalEggDefaultHatchingTime=float(data.get("PalEggDefaultHatchingTime", 0.0)),
+            WorkSpeedRate=float(data.get("WorkSpeedRate", 0.0)),
+            bIsMultiplay=bool(data.get("bIsMultiplay", False)),
+            bIsPvP=bool(data.get("bIsPvP", False)),
+            bCanPickupOtherGuildDeathPenaltyDrop=bool(
+                data.get("bCanPickupOtherGuildDeathPenaltyDrop", False)
+            ),
+            bEnableNonLoginPenalty=bool(data.get("bEnableNonLoginPenalty", False)),
+            bEnableFastTravel=bool(data.get("bEnableFastTravel", False)),
+            bIsStartLocationSelectByMap=bool(
+                data.get("bIsStartLocationSelectByMap", False)
+            ),
+            bExistPlayerAfterLogout=bool(data.get("bExistPlayerAfterLogout", False)),
+            bEnableDefenseOtherGuildPlayer=bool(
+                data.get("bEnableDefenseOtherGuildPlayer", False)
+            ),
+            CoopPlayerMaxNum=int(data.get("CoopPlayerMaxNum", 0)),
+            ServerPlayerMaxNum=int(data.get("ServerPlayerMaxNum", 0)),
+            ServerName=data.get("ServerName", ""),
+            ServerDescription=data.get("ServerDescription", ""),
+            PublicPort=int(data.get("PublicPort", 0)),
+            PublicIP=data.get("PublicIP", ""),
+            RCONEnabled=bool(data.get("RCONEnabled", False)),
+            RCONPort=int(data.get("RCONPort", 0)),
+            Region=data.get("Region", ""),
+            bUseAuth=bool(data.get("bUseAuth", False)),
+            BanListURL=data.get("BanListURL", ""),
+            RESTAPIEnabled=bool(data.get("RESTAPIEnabled", False)),
+            RESTAPIPort=int(data.get("RESTAPIPort", 0)),
+            bShowPlayerList=bool(data.get("bShowPlayerList", False)),
+            AllowConnectPlatform=data.get("AllowConnectPlatform", ""),
+            bIsUseBackupSaveData=bool(data.get("bIsUseBackupSaveData", False)),
+            LogFormatType=data.get("LogFormatType", ""),
+            raw=data,
+        )

palworld_restapi/py.typed

@@ -0,0 +1 @@
+# PEP 561 type hinting marker

palworld_restapi-0.7.3.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: palworld-restapi
+Version: 0.7.3
+Summary: This is a simple Palworld REST API Wrapper + CLI written in python.
+Project-URL: Repository, https://github.com/KJAyano/Palworld-RESTAPI
+Project-URL: Issues, https://github.com/KJAyano/Palworld-RESTAPI/issues
+Author: KJAyano
+License-File: LICENSE
+Requires-Python: >=3.14
+Requires-Dist: httpx<1,>=0.27
+Requires-Dist: python-dotenv
+Description-Content-Type: text/markdown
+
+# Palworld REST API
+
+[![PyPI version](https://badge.fury.io/py/palworld-restapi.svg)](https://pypi.org/project/palworld-restapi/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/palworld-restapi.svg)](https://pypi.org/project/palworld-restapi/)
+
+A modern, fast, and fully-typed Python client library and CLI wrapper for the official **Palworld Dedicated Server REST API**. Built on `httpx` to provide first-class support for both synchronous scripts and high-performance asynchronous applications.
+
+## Features
+
+- **Dual Clients**: Contains both `PalworldClient` (sync) and `AsyncPalworldClient` (async) using connection pooling for maximum performance.
+- **Strict Typing**: Fully typed with PEP 561 compliance. API responses are parsed into rigorous Python Dataclasses for safety and excellent IDE autocomplete.
+- **CLI Included**: Manage your Palworld server directly from your terminal using the built-in `palworld-cli`.
+- **Modern**: Formatted with `ruff`, built with `hatchling`, and rigorously tested.
+
+---
+
+## Installation
+
+You can install the package directly from PyPI:
+
+```bash
+pip install palworld-restapi
+```
+*(Or use `uv add palworld-restapi` if you are using `uv`)*
+
+---
+
+## Quickstart
+
+### Async Client (Recommended for Bots / Web Apps)
+```python
+import asyncio
+from palworld_restapi import AsyncPalworldClient
+
+async def main():
+    async with AsyncPalworldClient("http://127.0.0.1:8212", password="admin-password") as client:
+        info = await client.get_info()
+        print(f"Connected to {info.servername} (v{info.version})")
+        
+        # Announce a message to the server
+        await client.announce("Hello from Python!")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### Sync Client (Recommended for simple scripts)
+```python
+from palworld_restapi import PalworldClient
+
+with PalworldClient("http://127.0.0.1:8212", password="admin-password") as client:
+    players_resp = client.get_players()
+    print(f"There are currently {len(players_resp.players)} players online.")
+```
+
+---
+
+## Command Line Interface (CLI)
+
+The package ships with a built-in CLI to easily manage your server without writing code. It supports loading credentials from `.env` files automatically.
+
+```bash
+# Get server info
+palworld-cli info
+
+# See online players
+palworld-cli players
+
+# Kick a player by Steam ID
+palworld-cli kick steam_00000000000000000 --message "AFK too long"
+
+# Shut the server down in 60 seconds
+palworld-cli shutdown 60 --message "Restarting for an update!"
+```
+
+---
+
+## Documentation & Examples
+
+For full details, please refer to the documentation:
+- **[Usage Guide](https://github.com/KJAyano/Palworld-RESTAPI/blob/main/docs/USAGE_GUIDE.md)**: Deep dive into using the Python clients.
+- **[CLI Guide](https://github.com/KJAyano/Palworld-RESTAPI/blob/main/docs/CLI_GUIDE.md)**: Full command reference for the `palworld-cli` terminal tool.
+- **[Endpoints Reference](https://github.com/KJAyano/Palworld-RESTAPI/blob/main/docs/ENDPOINTS.md)**: Available endpoints and payload details.
+
+We also have a full suite of working scripts in the [`examples/`](https://github.com/KJAyano/Palworld-RESTAPI/tree/main/examples) directory demonstrating kick/ban management, player tracking, and server metrics.

palworld_restapi-0.7.3.dist-info/RECORD

@@ -0,0 +1,14 @@
+palworld_restapi/__init__.py,sha256=TDCOEXiJfjVAVTVFVBESvBJRn3pmtWZ0zOZqKT1CDjc,424
+palworld_restapi/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
+palworld_restapi/_core.py,sha256=s3Hv5hMe-QUZXhymFshGvKZhr005KJPo9r_pkljz_n4,869
+palworld_restapi/async_client.py,sha256=_Ud_eI5TxQxWdiXRfHo6dfMjTUI-bYH_l3999OAZmSs,3524
+palworld_restapi/cli.py,sha256=tE5El6MhhQOPfTt6ZdQxPpWsla5IDXiWIouX25jY-RI,4823
+palworld_restapi/client.py,sha256=W4pG1VHoyInvSDuE5Yk6WOSySGwaeYAMDQbvrSYPIeM,3341
+palworld_restapi/errors.py,sha256=CuDePaYCzXoYUzH47Kma-WspFPUEYvGQZniTGwUyqZ8,473
+palworld_restapi/models.py,sha256=UWoSlt2BCxbikJhb7GwsAK0npU8DkpNljJCV3ye7NM0,10163
+palworld_restapi/py.typed,sha256=CHI1GHUWh_37O6wIhLuQswalK0kOjarehBwBMSQ6e1Q,29
+palworld_restapi-0.7.3.dist-info/METADATA,sha256=W_ykEBxbZAnehLbgSmx8i2wIFSYfpv_CbnRQITWA0_A,3686
+palworld_restapi-0.7.3.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+palworld_restapi-0.7.3.dist-info/entry_points.txt,sha256=3DWz06AtgNVsmpoEr1x0Ylmvsm7G7kWeEuMpb4R5Wl0,59
+palworld_restapi-0.7.3.dist-info/licenses/LICENSE,sha256=uogv3EQohnej6pTCx0rjvNdwmlFFJS-qykOlEQmHaCk,1067
+palworld_restapi-0.7.3.dist-info/RECORD,,

palworld_restapi-0.7.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

palworld_restapi-0.7.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+palworld-cli = palworld_restapi.cli:main

palworld_restapi-0.7.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AyanoKouji
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.