prcpy-erlc 0.1.0__py3-none-any.whl

prcpy/__init__.py

@@ -0,0 +1,51 @@
+from .client import AsyncClient, Client
+from .errors import (
+    APIError,
+    AuthenticationError,
+    BadRequestError,
+    CommandError,
+    ERLCError,
+    RateLimitError,
+    ServerOfflineError,
+)
+from .models import (
+    CommandLog,
+    CommandResult,
+    EmergencyCall,
+    JoinLog,
+    KillLog,
+    Location,
+    ModCall,
+    Player,
+    Server,
+    Staff,
+    Vehicle,
+)
+from .rate_limits import RateLimitInfo
+from .webhooks import WebhookVerificationError, verify_signature
+
+__all__ = [
+    "APIError",
+    "AsyncClient",
+    "AuthenticationError",
+    "BadRequestError",
+    "Client",
+    "CommandError",
+    "CommandLog",
+    "CommandResult",
+    "ERLCError",
+    "EmergencyCall",
+    "JoinLog",
+    "KillLog",
+    "Location",
+    "ModCall",
+    "Player",
+    "RateLimitError",
+    "RateLimitInfo",
+    "Server",
+    "ServerOfflineError",
+    "Staff",
+    "Vehicle",
+    "WebhookVerificationError",
+    "verify_signature",
+]

prcpy/client.py

@@ -0,0 +1,360 @@
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Any
+
+import httpx
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+from .errors import (
+    APIError,
+    AuthenticationError,
+    BadRequestError,
+    CommandError,
+    RateLimitError,
+    ServerOfflineError,
+)
+from .models import (
+    CommandLog,
+    CommandResult,
+    JoinLog,
+    KillLog,
+    ModCall,
+    Player,
+    Server,
+    Staff,
+    Vehicle,
+)
+from .rate_limits import RateLimitInfo
+
+BASE_URL = "https://api.erlc.gg"
+
+_INCLUDE_MAP = {
+    "players": "Players",
+    "staff": "Staff",
+    "join_logs": "JoinLogs",
+    "queue": "Queue",
+    "kill_logs": "KillLogs",
+    "command_logs": "CommandLogs",
+    "mod_calls": "ModCalls",
+    "emergency_calls": "EmergencyCalls",
+    "vehicles": "Vehicles",
+}
+
+
+class _ClientBase:
+    def __init__(
+        self,
+        server_key: str,
+        *,
+        global_api_key: str | None = None,
+        base_url: str = BASE_URL,
+        timeout: float | httpx.Timeout = 30.0,
+    ) -> None:
+        if not server_key.strip():
+            raise ValueError("server_key must not be empty")
+        self.server_key = server_key
+        self.global_api_key = global_api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.rate_limit: RateLimitInfo | None = None
+
+    @classmethod
+    def from_env(cls, **kwargs: Any):
+        server_key = os.getenv("ERLC_SERVER_KEY")
+        if not server_key:
+            raise ValueError("ERLC_SERVER_KEY is not set")
+        return cls(
+            server_key,
+            global_api_key=os.getenv("ERLC_GLOBAL_API_KEY"),
+            **kwargs,
+        )
+
+    def _headers(self) -> dict[str, str]:
+        headers = {
+            "Accept": "application/json",
+            "server-key": self.server_key,
+            "User-Agent": "prcpy/0.1.0",
+        }
+        if self.global_api_key:
+            headers["Authorization"] = self.global_api_key
+        return headers
+
+    @staticmethod
+    def _include_params(flags: dict[str, bool]) -> dict[str, str]:
+        unknown = set(flags) - set(_INCLUDE_MAP)
+        if unknown:
+            names = ", ".join(sorted(unknown))
+            raise ValueError(f"Unknown server include(s): {names}")
+        return {
+            _INCLUDE_MAP[name]: "true"
+            for name, enabled in flags.items()
+            if enabled
+        }
+
+    def _raise_for_error(self, response: httpx.Response) -> None:
+        if response.is_success:
+            return
+        try:
+            payload = response.json()
+        except ValueError:
+            payload = None
+
+        if isinstance(payload, dict):
+            message = payload.get("message") or payload.get("error") or response.text
+            error_code = payload.get("code")
+            command_id = payload.get("commandId")
+        else:
+            message = response.text or response.reason_phrase
+            error_code = None
+            command_id = None
+
+        common = {
+            "status_code": response.status_code,
+            "error_code": error_code,
+            "details": payload,
+            "command_id": command_id,
+        }
+
+        if response.status_code == 403:
+            raise AuthenticationError(message, **common)
+        if response.status_code == 400:
+            raise BadRequestError(message, **common)
+        if response.status_code == 429:
+            retry_after = response.headers.get("Retry-After")
+            try:
+                retry_after_value = float(retry_after) if retry_after else None
+            except ValueError:
+                retry_after_value = None
+            raise RateLimitError(
+                message,
+                retry_after=retry_after_value,
+                bucket=self.rate_limit.bucket if self.rate_limit else None,
+                **common,
+            )
+        if response.status_code == 422:
+            raise ServerOfflineError(message, **common)
+        if response.request.method == "POST" and response.request.url.path.endswith("/command"):
+            raise CommandError(message, **common)
+        raise APIError(message, **common)
+
+    @staticmethod
+    def _json(response: httpx.Response) -> Any:
+        if not response.content:
+            return None
+        try:
+            return response.json()
+        except ValueError as exc:
+            raise APIError(
+                "The API returned an invalid JSON response.",
+                status_code=response.status_code,
+                details=response.text,
+            ) from exc
+
+
+class Client(_ClientBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._http = httpx.Client(timeout=self.timeout)
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()
+
+    def request(self, method: str, path: str, **kwargs: Any) -> Any:
+        response = self._http.request(
+            method,
+            f"{self.base_url}{path}" if path.startswith("/") else path,
+            headers=self._headers(),
+            **kwargs,
+        )
+        self.rate_limit = RateLimitInfo.from_headers(response.headers)
+        self._raise_for_error(response)
+        return self._json(response)
+
+    def get_server(
+        self,
+        *,
+        players: bool = False,
+        staff: bool = False,
+        join_logs: bool = False,
+        queue: bool = False,
+        kill_logs: bool = False,
+        command_logs: bool = False,
+        mod_calls: bool = False,
+        emergency_calls: bool = False,
+        vehicles: bool = False,
+    ) -> Server:
+        flags = {
+            "players": players,
+            "staff": staff,
+            "join_logs": join_logs,
+            "queue": queue,
+            "kill_logs": kill_logs,
+            "command_logs": command_logs,
+            "mod_calls": mod_calls,
+            "emergency_calls": emergency_calls,
+            "vehicles": vehicles,
+        }
+        return Server.from_api(
+            self.request("GET", "/v2/server", params=self._include_params(flags))
+        )
+
+    def get_players(self) -> list[Player]:
+        return [
+            Player.from_api(item)
+            for item in self.request("GET", "/v1/server/players")
+        ]
+
+    def get_staff(self) -> Staff:
+        return Staff.from_api(self.request("GET", "/v1/server/staff"))
+
+    def get_join_logs(self) -> list[JoinLog]:
+        return [
+            JoinLog.from_api(item)
+            for item in self.request("GET", "/v1/server/joinlogs")
+        ]
+
+    def get_queue(self) -> list[int]:
+        return self.request("GET", "/v1/server/queue")
+
+    def get_kill_logs(self) -> list[KillLog]:
+        return [
+            KillLog.from_api(item)
+            for item in self.request("GET", "/v1/server/killlogs")
+        ]
+
+    def get_command_logs(self) -> list[CommandLog]:
+        return [
+            CommandLog.from_api(item)
+            for item in self.request("GET", "/v1/server/commandlogs")
+        ]
+
+    def get_mod_calls(self) -> list[ModCall]:
+        return [
+            ModCall.from_api(item)
+            for item in self.request("GET", "/v1/server/modcalls")
+        ]
+
+    def get_bans(self) -> dict[str, Any]:
+        return self.request("GET", "/v1/server/bans")
+
+    def get_vehicles(self) -> list[Vehicle]:
+        return [
+            Vehicle.from_api(item)
+            for item in self.request("GET", "/v1/server/vehicles")
+        ]
+
+    def send_command(self, command: str) -> CommandResult:
+        if not command.strip():
+            raise ValueError("command must not be empty")
+        return CommandResult.from_api(
+            self.request("POST", "/v2/server/command", json={"command": command})
+        )
+
+
+class AsyncClient(_ClientBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._http = httpx.AsyncClient(timeout=self.timeout)
+
+    async def aclose(self) -> None:
+        await self._http.aclose()
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(self, *_: object) -> None:
+        await self.aclose()
+
+    async def request(self, method: str, path: str, **kwargs: Any) -> Any:
+        response = await self._http.request(
+            method,
+            f"{self.base_url}{path}" if path.startswith("/") else path,
+            headers=self._headers(),
+            **kwargs,
+        )
+        self.rate_limit = RateLimitInfo.from_headers(response.headers)
+        self._raise_for_error(response)
+        return self._json(response)
+
+    async def get_server(
+        self,
+        *,
+        players: bool = False,
+        staff: bool = False,
+        join_logs: bool = False,
+        queue: bool = False,
+        kill_logs: bool = False,
+        command_logs: bool = False,
+        mod_calls: bool = False,
+        emergency_calls: bool = False,
+        vehicles: bool = False,
+    ) -> Server:
+        flags = {
+            "players": players,
+            "staff": staff,
+            "join_logs": join_logs,
+            "queue": queue,
+            "kill_logs": kill_logs,
+            "command_logs": command_logs,
+            "mod_calls": mod_calls,
+            "emergency_calls": emergency_calls,
+            "vehicles": vehicles,
+        }
+        data = await self.request(
+            "GET",
+            "/v2/server",
+            params=self._include_params(flags),
+        )
+        return Server.from_api(data)
+
+    async def get_players(self) -> list[Player]:
+        data = await self.request("GET", "/v1/server/players")
+        return [Player.from_api(item) for item in data]
+
+    async def get_staff(self) -> Staff:
+        return Staff.from_api(await self.request("GET", "/v1/server/staff"))
+
+    async def get_join_logs(self) -> list[JoinLog]:
+        data = await self.request("GET", "/v1/server/joinlogs")
+        return [JoinLog.from_api(item) for item in data]
+
+    async def get_queue(self) -> list[int]:
+        return await self.request("GET", "/v1/server/queue")
+
+    async def get_kill_logs(self) -> list[KillLog]:
+        data = await self.request("GET", "/v1/server/killlogs")
+        return [KillLog.from_api(item) for item in data]
+
+    async def get_command_logs(self) -> list[CommandLog]:
+        data = await self.request("GET", "/v1/server/commandlogs")
+        return [CommandLog.from_api(item) for item in data]
+
+    async def get_mod_calls(self) -> list[ModCall]:
+        data = await self.request("GET", "/v1/server/modcalls")
+        return [ModCall.from_api(item) for item in data]
+
+    async def get_bans(self) -> dict[str, Any]:
+        return await self.request("GET", "/v1/server/bans")
+
+    async def get_vehicles(self) -> list[Vehicle]:
+        data = await self.request("GET", "/v1/server/vehicles")
+        return [Vehicle.from_api(item) for item in data]
+
+    async def send_command(self, command: str) -> CommandResult:
+        if not command.strip():
+            raise ValueError("command must not be empty")
+        data = await self.request(
+            "POST",
+            "/v2/server/command",
+            json={"command": command},
+        )
+        return CommandResult.from_api(data)

prcpy/errors.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class ERLCError(Exception):
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int | None = None,
+        error_code: int | str | None = None,
+        details: Any = None,
+        command_id: str | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.error_code = error_code
+        self.details = details
+        self.command_id = command_id
+
+    def __str__(self) -> str:
+        return self.message
+
+
+class APIError(ERLCError):
+    pass
+
+
+class AuthenticationError(APIError):
+    pass
+
+
+class BadRequestError(APIError):
+    pass
+
+
+class RateLimitError(APIError):
+    def __init__(
+        self,
+        message: str,
+        *,
+        retry_after: float | None = None,
+        bucket: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(message, **kwargs)
+        self.retry_after = retry_after
+        self.bucket = bucket
+
+
+class ServerOfflineError(APIError):
+    pass
+
+
+class CommandError(APIError):
+    pass

prcpy/models.py

@@ -0,0 +1,265 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field, fields
+from typing import Any
+
+
+@dataclass(slots=True)
+class Model:
+    raw: dict[str, Any] = field(default_factory=dict, repr=False)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            item.name: getattr(self, item.name)
+            for item in fields(self)
+            if item.name != "raw"
+        }
+
+
+@dataclass(slots=True)
+class Location(Model):
+    x: float | None = None
+    z: float | None = None
+    postal_code: str | None = None
+    street_name: str | None = None
+    building_number: str | None = None
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> Location:
+        return cls(
+            x=data.get("LocationX"),
+            z=data.get("LocationZ"),
+            postal_code=data.get("PostalCode"),
+            street_name=data.get("StreetName"),
+            building_number=data.get("BuildingNumber"),
+            raw=data,
+        )
+
+
+@dataclass(slots=True)
+class Player(Model):
+    username: str = ""
+    roblox_id: int | None = None
+    team: str = ""
+    permission: str = ""
+    callsign: str | None = None
+    location: Location | None = None
+    wanted_stars: int = 0
+
+    @property
+    def is_wanted(self) -> bool:
+        return self.wanted_stars > 0
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> Player:
+        value = data.get("Player", "")
+        username, separator, identifier = value.partition(":")
+        try:
+            roblox_id = int(identifier) if separator and identifier else None
+        except ValueError:
+            roblox_id = None
+        location = data.get("Location")
+        return cls(
+            username=username or value,
+            roblox_id=roblox_id,
+            team=data.get("Team", ""),
+            permission=data.get("Permission", ""),
+            callsign=data.get("Callsign"),
+            location=Location.from_api(location) if isinstance(location, dict) else None,
+            wanted_stars=data.get("WantedStars", 0),
+            raw=data,
+        )
+
+
+@dataclass(slots=True)
+class Staff(Model):
+    co_owner_ids: list[int] = field(default_factory=list)
+    admins: dict[str, str] = field(default_factory=dict)
+    mods: dict[str, str] = field(default_factory=dict)
+    helpers: dict[str, str] = field(default_factory=dict)
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> Staff:
+        return cls(
+            co_owner_ids=data.get("CoOwners", []),
+            admins=data.get("Admins", {}),
+            mods=data.get("Mods", {}),
+            helpers=data.get("Helpers", {}),
+            raw=data,
+        )
+
+
+@dataclass(slots=True)
+class JoinLog(Model):
+    joined: bool = False
+    timestamp: int = 0
+    player: str = ""
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> JoinLog:
+        return cls(
+            joined=data.get("Join", False),
+            timestamp=data.get("Timestamp", 0),
+            player=data.get("Player", ""),
+            raw=data,
+        )
+
+
+@dataclass(slots=True)
+class KillLog(Model):
+    killed: str = ""
+    timestamp: int = 0
+    killer: str = ""
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> KillLog:
+        return cls(
+            killed=data.get("Killed", ""),
+            timestamp=data.get("Timestamp", 0),
+            killer=data.get("Killer", ""),
+            raw=data,
+        )
+
+
+@dataclass(slots=True)
+class CommandLog(Model):
+    player: str = ""
+    timestamp: int = 0
+    command: str = ""
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> CommandLog:
+        return cls(
+            player=data.get("Player", ""),
+            timestamp=data.get("Timestamp", 0),
+            command=data.get("Command", ""),
+            raw=data,
+        )
+
+
+@dataclass(slots=True)
+class ModCall(Model):
+    caller: str = ""
+    moderator: str | None = None
+    timestamp: int = 0
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> ModCall:
+        return cls(
+            caller=data.get("Caller", ""),
+            moderator=data.get("Moderator"),
+            timestamp=data.get("Timestamp", 0),
+            raw=data,
+        )
+
+
+@dataclass(slots=True)
+class EmergencyCall(Model):
+    team: str = ""
+    caller_id: int | None = None
+    player_ids: list[int] = field(default_factory=list)
+    position: tuple[float, float] | None = None
+    started_at: int = 0
+    call_number: int | None = None
+    description: str = ""
+    position_descriptor: str = ""
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> EmergencyCall:
+        position = data.get("Position")
+        coordinates = (
+            (float(position[0]), float(position[1]))
+            if isinstance(position, list) and len(position) >= 2
+            else None
+        )
+        return cls(
+            team=data.get("Team", ""),
+            caller_id=data.get("Caller"),
+            player_ids=data.get("Players", []),
+            position=coordinates,
+            started_at=data.get("StartedAt", 0),
+            call_number=data.get("CallNumber"),
+            description=data.get("Description", ""),
+            position_descriptor=data.get("PositionDescriptor", ""),
+            raw=data,
+        )
+
+
+@dataclass(slots=True)
+class Vehicle(Model):
+    name: str = ""
+    owner: str = ""
+    plate: str | None = None
+    texture: str | None = None
+    color_hex: str | None = None
+    color_name: str | None = None
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> Vehicle:
+        return cls(
+            name=data.get("Name", ""),
+            owner=data.get("Owner", ""),
+            plate=data.get("Plate"),
+            texture=data.get("Texture"),
+            color_hex=data.get("ColorHex"),
+            color_name=data.get("ColorName"),
+            raw=data,
+        )
+
+
+@dataclass(slots=True)
+class Server(Model):
+    name: str = ""
+    owner_id: int = 0
+    co_owner_ids: list[int] = field(default_factory=list)
+    current_players: int = 0
+    max_players: int = 0
+    join_key: str = ""
+    account_verification_requirement: str = ""
+    team_balance: bool = False
+    players: list[Player] | None = None
+    staff: Staff | None = None
+    join_logs: list[JoinLog] | None = None
+    queue: list[int] | None = None
+    kill_logs: list[KillLog] | None = None
+    command_logs: list[CommandLog] | None = None
+    mod_calls: list[ModCall] | None = None
+    emergency_calls: list[EmergencyCall] | None = None
+    vehicles: list[Vehicle] | None = None
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> Server:
+        return cls(
+            name=data.get("Name", ""),
+            owner_id=data.get("OwnerId", 0),
+            co_owner_ids=data.get("CoOwnerIds", []),
+            current_players=data.get("CurrentPlayers", 0),
+            max_players=data.get("MaxPlayers", 0),
+            join_key=data.get("JoinKey", ""),
+            account_verification_requirement=data.get("AccVerifiedReq", ""),
+            team_balance=data.get("TeamBalance", False),
+            players=[Player.from_api(item) for item in data["Players"]] if "Players" in data else None,
+            staff=Staff.from_api(data["Staff"]) if "Staff" in data else None,
+            join_logs=[JoinLog.from_api(item) for item in data["JoinLogs"]] if "JoinLogs" in data else None,
+            queue=data.get("Queue"),
+            kill_logs=[KillLog.from_api(item) for item in data["KillLogs"]] if "KillLogs" in data else None,
+            command_logs=[CommandLog.from_api(item) for item in data["CommandLogs"]] if "CommandLogs" in data else None,
+            mod_calls=[ModCall.from_api(item) for item in data["ModCalls"]] if "ModCalls" in data else None,
+            emergency_calls=[EmergencyCall.from_api(item) for item in data["EmergencyCalls"]] if "EmergencyCalls" in data else None,
+            vehicles=[Vehicle.from_api(item) for item in data["Vehicles"]] if "Vehicles" in data else None,
+            raw=data,
+        )
+
+
+@dataclass(slots=True)
+class CommandResult(Model):
+    message: str = ""
+    command_id: str | None = None
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> CommandResult:
+        return cls(
+            message=data.get("message", ""),
+            command_id=data.get("commandId"),
+            raw=data,
+        )

prcpy/rate_limits.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(slots=True, frozen=True)
+class RateLimitInfo:
+    bucket: str | None = None
+    limit: int | None = None
+    remaining: int | None = None
+    reset: int | None = None
+
+    @classmethod
+    def from_headers(cls, headers: object) -> RateLimitInfo:
+        get = headers.get
+
+        def integer(name: str) -> int | None:
+            value = get(name)
+            if value is None:
+                return None
+            try:
+                return int(value)
+            except (TypeError, ValueError):
+                return None
+
+        return cls(
+            bucket=get("X-RateLimit-Bucket"),
+            limit=integer("X-RateLimit-Limit"),
+            remaining=integer("X-RateLimit-Remaining"),
+            reset=integer("X-RateLimit-Reset"),
+        )

prcpy/webhooks.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import base64
+import binascii
+
+
+class WebhookVerificationError(ValueError):
+    pass
+
+
+def _load_public_key(value: str):
+    from cryptography.hazmat.primitives import serialization
+    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+
+    candidates: list[bytes] = []
+    try:
+        candidates.append(bytes.fromhex(value))
+    except ValueError:
+        pass
+    try:
+        candidates.append(base64.b64decode(value, validate=True))
+    except (ValueError, binascii.Error):
+        pass
+
+    for data in candidates:
+        if len(data) == 32:
+            return Ed25519PublicKey.from_public_bytes(data)
+        try:
+            return serialization.load_der_public_key(data)
+        except ValueError:
+            continue
+
+    raise WebhookVerificationError("Invalid Ed25519 public key.")
+
+
+def verify_signature(
+    timestamp: str,
+    signature: str,
+    body: bytes,
+    *,
+    public_key: str,
+) -> bool:
+    try:
+        from cryptography.exceptions import InvalidSignature
+    except ImportError as exc:
+        raise RuntimeError(
+            'Install "prcpy-erlc[webhooks]" to verify webhook signatures.'
+        ) from exc
+
+    try:
+        signature_bytes = bytes.fromhex(signature)
+    except (ValueError, binascii.Error) as exc:
+        raise WebhookVerificationError("Invalid webhook signature.") from exc
+
+    try:
+        key = _load_public_key(public_key)
+        key.verify(signature_bytes, timestamp.encode("utf-8") + body)
+    except InvalidSignature:
+        return False
+
+    return True

prcpy_erlc-0.1.0.dist-info/METADATA

@@ -0,0 +1,248 @@
+Metadata-Version: 2.5
+Name: prcpy-erlc
+Version: 0.1.0
+Summary: A typed Python client for the ER:LC Private Server API.
+Project-URL: Documentation, https://apidocs.erlc.gg/
+Project-URL: Repository, https://github.com/Metolix/erlcpy
+Project-URL: Issues, https://github.com/Metolix/erlcpy/issues
+Author: Sidhak Singh
+License: MIT License
+        
+        Copyright (c) 2026 Sidhak Singh
+        
+        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.
+License-File: LICENSE
+Keywords: api,erlc,private-server,python,roblox
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx<1,>=0.27
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: cryptography>=42; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: webhooks
+Requires-Dist: cryptography>=42; extra == 'webhooks'
+Description-Content-Type: text/markdown
+
+# prcpy
+
+A typed Python client for the ER:LC Private Server API.
+
+prcpy provides synchronous and asynchronous clients, typed response models, rate-limit metadata, structured exceptions, webhook helpers, and a low-level request interface for endpoints that are added to the API later.
+
+> prcpy is an independent open-source project and is not affiliated with or endorsed by ER:LC or PRC.
+
+## Requirements
+
+- Python 3.10+
+- An ER:LC private server with API access
+- A server key from the server's API settings
+
+## Installation
+
+```bash
+pip install prcpy-erlc
+```
+
+For webhook signature verification:
+
+```bash
+pip install "prcpy-erlc[webhooks]"
+```
+
+## Quick start
+
+```python
+from prcpy import Client
+
+with Client("your-server-key") as client:
+    server = client.get_server(players=True)
+
+    print(server.name)
+    print(f"{server.current_players}/{server.max_players}")
+
+    for player in server.players or []:
+        print(player.username, player.team)
+```
+
+## Async
+
+```python
+from prcpy import AsyncClient
+
+async with AsyncClient("your-server-key") as client:
+    server = await client.get_server(players=True)
+    print(server.name)
+```
+
+## Available server data
+
+The v2 server endpoint supports these optional resources:
+
+- `players`
+- `staff`
+- `join_logs`
+- `queue`
+- `kill_logs`
+- `command_logs`
+- `mod_calls`
+- `emergency_calls`
+- `vehicles`
+
+Only request the data an application needs.
+
+```python
+server = client.get_server(
+    players=True,
+    staff=True,
+    vehicles=True,
+    emergency_calls=True,
+)
+```
+
+## Convenience methods
+
+```python
+players = client.get_players()
+staff = client.get_staff()
+join_logs = client.get_join_logs()
+queue = client.get_queue()
+kill_logs = client.get_kill_logs()
+command_logs = client.get_command_logs()
+mod_calls = client.get_mod_calls()
+vehicles = client.get_vehicles()
+bans = client.get_bans()
+```
+
+## Commands
+
+```python
+result = client.send_command(":h Hello from prcpy")
+print(result.message)
+```
+
+The API documents a `commandId` on command failures. prcpy exposes it as `CommandError.command_id` or `ServerOfflineError.command_id` when supplied by the API.
+
+## Authentication
+
+All API requests use the `server-key` header.
+
+Public applications may also provide a global API key:
+
+```python
+client = Client(
+    "server-key",
+    global_api_key="global-api-key",
+)
+```
+
+Environment variables are supported:
+
+```text
+ERLC_SERVER_KEY=...
+ERLC_GLOBAL_API_KEY=...
+```
+
+```python
+client = Client.from_env()
+```
+
+Never commit keys to source control.
+
+## Rate limits
+
+The client reads the API's `X-RateLimit-Bucket`, `X-RateLimit-Limit`, `X-RateLimit-Remaining`, and `X-RateLimit-Reset` response headers.
+
+```python
+client.get_server()
+print(client.rate_limit)
+```
+
+A 429 response raises `RateLimitError` with `retry_after` when the server provides a `Retry-After` header.
+
+prcpy does not silently retry commands. This avoids accidentally executing an in-game command more than once.
+
+## Raw API access
+
+The typed methods cover the documented API, but the API can grow independently of this package.
+
+```python
+data = client.request("GET", "/v2/server", params={"Players": "true"})
+```
+
+## Webhooks
+
+prcpy includes a small helper for Ed25519 webhook verification:
+
+```python
+from prcpy.webhooks import verify_signature
+
+verify_signature(
+    timestamp=request.headers["X-Signature-Timestamp"],
+    signature=request.headers["X-Signature-Ed25519"],
+    body=raw_request_body,
+    public_key="your-webhook-public-key",
+)
+```
+
+Always verify the raw request body before parsing JSON.
+
+## Development
+
+```bash
+python -m pip install -e ".[dev]"
+ruff check .
+pytest
+```
+
+## Project structure
+
+```text
+prcpy/
+├── docs/
+├── examples/
+├── src/prcpy/
+│   ├── client.py
+│   ├── errors.py
+│   ├── models.py
+│   ├── rate_limits.py
+│   └── webhooks.py
+├── tests/
+├── .github/workflows/
+├── CONTRIBUTING.md
+├── LICENSE
+├── pyproject.toml
+└── README.md
+```
+
+## License
+
+MIT

prcpy_erlc-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+prcpy/__init__.py,sha256=OEcz7uvKCQ5fgyPVS1_f4BHyrEsUkOA4bQ2phWRajN8,937
+prcpy/client.py,sha256=y6kIxBNpfO8_tZyoOxjCIvbcl0RE47xDXPlU4Lm04a8,11224
+prcpy/errors.py,sha256=zrOLS305RpA2FkcpDENSD2UJOAjH80ZiTvWxdo29HNE,1134
+prcpy/models.py,sha256=bZojYy1w5wDi-NthMnT1u0XfMNvA5fnQCH_hP-b3qoA,8259
+prcpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+prcpy/rate_limits.py,sha256=gpYcfMXoD4egOTPRqj4BnciQ3kuIwXc5TqK2qHVEEvA,842
+prcpy/webhooks.py,sha256=ASGqgrMVViNcglLNejPazucJx7Nd9OphwtelPWEmZXk,1581
+prcpy_erlc-0.1.0.dist-info/METADATA,sha256=4BPFNYkTrwNPMlEEpZ4lpqne8Hus6y-yHI9RTcO7pY0,6555
+prcpy_erlc-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+prcpy_erlc-0.1.0.dist-info/licenses/LICENSE,sha256=NwC3LB3tBuPeYr4Ffl2oYKuPcqEMo5F-6US7ZXoiTjw,1069
+prcpy_erlc-0.1.0.dist-info/RECORD,,

prcpy_erlc-0.1.0.dist-info/WHEEL

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

prcpy_erlc-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sidhak Singh
+
+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.