rustplus 6.1.3__tar.gz → 6.2.1__tar.gz

{rustplus-6.1.3/rustplus.egg-info → rustplus-6.2.1}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: rustplus
-Version: 6.1.3
+Version: 6.2.1
 Summary: A python wrapper for the Rust Plus API
 Home-page: https://github.com/olijeffers0n/rustplus
 Author: olijeffers0n
 License: MIT
 Project-URL: Issue tracker, https://github.com/olijeffers0n/rustplus/issues
-Requires-Python: >=3.8.0
+Requires-Python: >=3.10.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: websockets

{rustplus-6.1.3 → rustplus-6.2.1}/rustplus/__init__.py

@@ -22,5 +22,5 @@ from .structs import RustError, RustMarker, Vector
 
 __name__ = "rustplus"
 __author__ = "olijeffers0n"
-__version__ = "6.1.3"
+__version__ = "6.2.1"
 __support__ = "Discord: https://discord.gg/nQqJe8qvP8"

{rustplus-6.1.3 → rustplus-6.2.1}/rustplus/commands/command_options.py

@@ -2,7 +2,7 @@ from ..exceptions import PrefixNotDefinedError
 
 
 class CommandOptions:
-    def __init__(self, prefix: str = None) -> None:
+    def __init__(self, prefix: str) -> None:
         if prefix is None:
             raise PrefixNotDefinedError("No prefix")
 

{rustplus-6.1.3 → rustplus-6.2.1}/rustplus/events/chat_event.py

@@ -1,14 +1,12 @@
 from rustplus.identification.handler_list import HandlerList
 from ..structs import RustChatMessage
 
-from typing import Union
-
 
 class ChatEventPayload:
     HANDLER_LIST = HandlerList()
 
     def __init__(
-        self, message: RustChatMessage, is_clan: bool, clan_id: Union[int, None]
+        self, message: RustChatMessage, is_clan: bool, clan_id: int | None
     ) -> None:
         self._message = message
         self._is_clan = is_clan
@@ -23,5 +21,5 @@ class ChatEventPayload:
         return self._is_clan
 
     @property
-    def clan_id(self) -> Union[int, None]:
+    def clan_id(self) -> int | None:
         return self._clan_id

rustplus-6.2.1/rustplus/identification/__init__.py

@@ -0,0 +1,2 @@
+from .registered_listener import RegisteredListener
+from .server_details import ServerDetails, DirectEndpoint, RelayEndpoint

rustplus-6.2.1/rustplus/identification/server_details.py

@@ -0,0 +1,85 @@
+import base64
+import time
+from dataclasses import dataclass, field
+
+from websockets.typing import Subprotocol
+
+
+def _b64url(s: str) -> str:
+    return base64.urlsafe_b64encode(s.encode()).decode().rstrip("=")
+
+
+@dataclass(frozen=True)
+class DirectEndpoint:
+    ip: str
+    port: int | None = None
+    secure: bool = False
+
+    def id(self) -> str:
+        return f"{self.ip}:{self.port}" if self.port is not None else self.ip
+
+    def uri(self) -> str:
+        scheme = "wss" if self.secure else "ws"
+        host = self.ip if self.port is None else f"{self.ip}:{self.port}"
+        return f"{scheme}://{host}"
+
+    @staticmethod
+    def connect_kwargs() -> dict:
+        return {}
+
+
+@dataclass(frozen=True)
+class RelayEndpoint:
+    server_id: str
+    # secret and short-lived: excluded from repr, eq and hash
+    auth_token: str = field(repr=False, compare=False)
+    host: str = "companion-rust.facepunch.com"
+    version: int = int(time.time() * 1000)
+
+    def id(self) -> str:
+        return self.server_id
+
+    def uri(self) -> str:
+        return f"wss://{self.host}/socket/{self.server_id}?v={self.version}"
+
+    def connect_kwargs(self) -> dict:
+        return {
+            "subprotocols": [
+                Subprotocol("rustplus.auth.v1"),
+                Subprotocol(_b64url(self.auth_token)),
+            ],
+            "origin": "https://app.playrust.com",
+        }
+
+
+Endpoint = DirectEndpoint | RelayEndpoint
+
+
+@dataclass(frozen=True)
+class ServerDetails:
+    endpoint: Endpoint
+    player_id: int
+    player_token: int = field(repr=False)
+
+    @classmethod
+    def direct(
+        cls,
+        ip: str,
+        port: int | None,
+        player_id: int,
+        player_token: int,
+        secure: bool = False,
+    ):
+        return cls(
+            DirectEndpoint(str(ip), int(port) if port else None, secure),
+            int(player_id),
+            int(player_token),
+        )
+
+    @classmethod
+    def facepunch(
+        cls, server_id: str, auth_token: str, player_id: int, player_token: int
+    ):
+        return cls(
+            RelayEndpoint(server_id, auth_token), int(player_id), int(player_token)
+        )

{rustplus-6.1.3 → rustplus-6.2.1}/rustplus/remote/camera/camera_manager.py

@@ -1,5 +1,5 @@
 import time
-from typing import Iterable, Union, List, Coroutine, Set, Callable
+from typing import Iterable, List, Coroutine, Set, Callable
 from PIL import Image
 
 from .camera_parser import Parser
@@ -18,7 +18,7 @@ from .structures import CameraInfo, Entity, LimitedQueue
 
 class CameraManager:
 
-    ACTIVE_INSTANCE: Union["CameraManager", None] = None
+    ACTIVE_INSTANCE: "CameraManager | None" = None
 
     def __init__(
         self, rust_socket, cam_id: str, cam_info_message: AppCameraInfo
@@ -60,7 +60,7 @@ class CameraManager:
         render_entities: bool = True,
         entity_render_distance: float | int = float("inf"),
         max_entity_amount: float | int = float("inf"),
-    ) -> Union[Image.Image, None]:
+    ) -> Image.Image | None:
         if self._last_packets is None:
             return None
 
@@ -97,7 +97,7 @@ class CameraManager:
         render_entities: bool = True,
         entity_render_distance: float | int = float("inf"),
         max_entity_amount: float | int = float("inf"),
-    ) -> Union[Image.Image, None]:
+    ) -> Image.Image | None:
         return await self._create_frame(
             render_entities, entity_render_distance, max_entity_amount
         )

{rustplus-6.1.3 → rustplus-6.2.1}/rustplus/remote/camera/camera_parser.py

@@ -2,7 +2,7 @@ import math
 from importlib import resources
 from math import radians, tan
 import random
-from typing import Union, Tuple, List, Any, Dict
+from typing import Tuple, List, Any, Dict
 import numpy as np
 from scipy.spatial import ConvexHull
 from PIL import Image, ImageDraw, ImageFont
@@ -166,7 +166,7 @@ class Parser:
 
         return False
 
-    def next_ray(self, ray_data) -> List[Union[float, int]]:
+    def next_ray(self, ray_data) -> List[float | int]:
         byte = ray_data[self.data_pointer]
         self.data_pointer += 1
 

{rustplus-6.1.3 → rustplus-6.2.1}/rustplus/remote/ratelimiter/__init__.py

@@ -64,8 +64,8 @@ class RateLimiter:
                 self.socket_buckets[server_details] = TokenBucket(
                     current, maximum, refresh_rate, refresh_amount
                 )
-            if server_details.get_server_string() not in self.server_buckets:
-                self.server_buckets[server_details.get_server_string()] = TokenBucket(
+            if server_details.endpoint.id() not in self.server_buckets:
+                self.server_buckets[server_details.endpoint.id()] = TokenBucket(
                     self.SERVER_LIMIT, self.SERVER_LIMIT, 1, self.SERVER_REFRESH_AMOUNT
                 )
 
@@ -76,7 +76,7 @@ class RateLimiter:
         with self.lock:
             for bucket in [
                 self.socket_buckets.get(server_details),
-                self.server_buckets.get(server_details.get_server_string()),
+                self.server_buckets.get(server_details.endpoint.id()),
             ]:
                 bucket.refresh()
                 if not bucket.can_consume(amount):
@@ -90,14 +90,14 @@ class RateLimiter:
         with self.lock:
             for bucket in [
                 self.socket_buckets.get(server_details),
-                self.server_buckets.get(server_details.get_server_string()),
+                self.server_buckets.get(server_details.endpoint.id()),
             ]:
                 bucket.refresh()
                 if not bucket.can_consume(amount):
                     raise RateLimitError("Not Enough Tokens")
             for bucket in [
                 self.socket_buckets.get(server_details),
-                self.server_buckets.get(server_details.get_server_string()),
+                self.server_buckets.get(server_details.endpoint.id()),
             ]:
                 bucket.consume(amount)
 
@@ -112,7 +112,7 @@ class RateLimiter:
             delay = 0
             for bucket in [
                 self.socket_buckets.get(server_details),
-                self.server_buckets.get(server_details.get_server_string()),
+                self.server_buckets.get(server_details.endpoint.id()),
             ]:
                 bucket.refresh()
                 val = (
@@ -135,8 +135,6 @@ class RateLimiter:
         """
         with self.lock:
             del self.socket_buckets[server_details]
-            server_str = server_details.get_server_string()
-            if not any(
-                d.get_server_string() == server_str for d in self.socket_buckets
-            ):
+            server_str = server_details.endpoint.id()
+            if not any(d.endpoint.id() == server_str for d in self.socket_buckets):
                 del self.server_buckets[server_str]

{rustplus-6.1.3 → rustplus-6.2.1}/rustplus/remote/websocket/ws.py

@@ -1,16 +1,14 @@
 import shlex
-import base64
 import betterproto
 from websockets.exceptions import InvalidURI, InvalidHandshake, ConnectionClosedError
 from websockets.legacy.client import WebSocketClientProtocol
 from websockets.client import connect
 from asyncio import TimeoutError, Task, AbstractEventLoop
-from typing import Union, Coroutine, Optional, Set, Dict
+from typing import Coroutine, Optional, Set, Dict
 import logging
 import asyncio
 
 from ..camera import CameraManager
-from ..proxy import ProxyValueGrabber
 from ..rustplus_proto import AppMessage, AppRequest, AppError
 from ...commands import CommandOptions, ChatCommand, ChatCommandTime
 from ...events import (
@@ -21,7 +19,10 @@ from ...events import (
 )
 from ...events.clan_info_event import ClanInfoEventPayload
 from ...exceptions import RequestError
-from ...identification import ServerDetails, RegisteredListener
+from ...identification import (
+    ServerDetails,
+    RegisteredListener,
+)
 from ...structs import RustChatMessage, RustTeamInfo, RustClanInfo
 from ...utils import YieldingEvent, convert_time
 from ...utils.utils import error_present
@@ -33,33 +34,21 @@ class RustWebsocket:
     def __init__(
         self,
         server_details: ServerDetails,
-        command_options: Union[CommandOptions, None],
-        use_fp_proxy: bool,
-        use_test_server: bool,
+        command_options: CommandOptions | None,
         debug: bool,
     ) -> None:
         self.server_details: ServerDetails = server_details
-        self.command_options: Union[CommandOptions, None] = command_options
-        self.connection: Union[WebSocketClientProtocol, None] = None
+        self.command_options: CommandOptions | None = command_options
+        self.connection: WebSocketClientProtocol | None = None
         self.logger: logging.Logger = logging.getLogger("rustplus.py")
-        self.task: Union[Task, None] = None
+        self.task: Task | None = None
         self.debug: bool = debug
-        self.use_test_server: bool = use_test_server
-        self.use_fp_proxy: bool = use_fp_proxy
 
         self.responses: Dict[int, YieldingEvent] = {}
         self.open = False
 
     async def connect(self) -> bool:
-
-        address = (
-            (
-                f"{'wss' if self.server_details.secure else 'ws'}://"
-                + self.server_details.get_server_string()
-            )
-            if not self.use_fp_proxy
-            else f"wss://companion-rust.facepunch.com/game/{self.server_details.ip}/{self.server_details.port}"
-        ) + f"?v={ProxyValueGrabber.get_value()}"
+        address = self.server_details.endpoint.uri()
 
         try:
             self.connection = await connect(
@@ -67,6 +56,7 @@ class RustWebsocket:
                 close_timeout=0,
                 ping_interval=None,
                 max_size=1_000_000_000,
+                **self.server_details.endpoint.connect_kwargs(),
             )
         except (InvalidURI, OSError, InvalidHandshake, TimeoutError) as err:
             self.logger.warning("WebSocket connection error: %s", err)
@@ -100,15 +90,25 @@ class RustWebsocket:
     async def run(self) -> None:
         while self.open:
             try:
-                data = await self.connection.recv()
+                if self.connection is None:
+                    self.logger.warning(
+                        "No Current Websocket Connection, exiting run loop"
+                    )
+                    break
+
+                data: str | bytes = await self.connection.recv()
+
+                if isinstance(data, str):
+                    # Text frame: not protobuf, so ignore it
+                    self.logger.warning(
+                        "Ignoring unexpected text frame (%d chars)", len(data)
+                    )
+                    continue
 
                 await self.run_coroutine_non_blocking(
                     self.run_proto_event(data, self.server_details)
                 )
 
-                if self.use_test_server:
-                    data = base64.b64decode(data)
-
                 app_message = AppMessage()
                 app_message.parse(data)
 
@@ -134,7 +134,7 @@ class RustWebsocket:
                     e,
                 )
 
-    async def send_and_get(self, request: AppRequest) -> AppMessage:
+    async def send_and_get(self, request: AppRequest) -> AppMessage | None:
         if not await self.send_message(request):
             message = AppMessage()
             error = AppError()
@@ -158,19 +158,14 @@ class RustWebsocket:
             self.responses[request.seq] = YieldingEvent()
 
         try:
-            if self.use_test_server:
-                await self.connection.send(
-                    base64.b64encode(bytes(request)).decode("utf-8")
-                )
-            else:
-                await self.connection.send(bytes(request))
+            await self.connection.send(bytes(request))
         except Exception as err:
             self.logger.warning("WebSocket connection error: %s", err)
             return False
 
         return True
 
-    async def get_response(self, seq: int) -> Union[AppMessage, None]:
+    async def get_response(self, seq: int) -> AppMessage | None:
 
         response = await self.responses[seq].wait(timeout=self.RESPONSE_TIMEOUT)
         del self.responses[seq]
@@ -185,7 +180,9 @@ class RustWebsocket:
 
         if error_present(app_message):
 
-            event: YieldingEvent = self.responses.get(app_message.response.seq, None)
+            event: YieldingEvent | None = self.responses.get(
+                app_message.response.seq, None
+            )
             if event is not None:
                 if self.debug:
                     self.logger.info(
@@ -315,7 +312,9 @@ class RustWebsocket:
 
         else:
             # This means that it wasn't sent by the server and is a message from the server in response to an action
-            event: YieldingEvent = self.responses.get(app_message.response.seq, None)
+            event: YieldingEvent | None = self.responses.get(
+                app_message.response.seq, None
+            )
             if event is not None:
                 if self.debug:
                     self.logger.info(f"Running Response Event: {app_message}")
@@ -333,9 +332,7 @@ class RustWebsocket:
             return None
 
     @staticmethod
-    async def run_proto_event(
-        data: Union[str, bytes], server_details: ServerDetails
-    ) -> None:
+    async def run_proto_event(data: str | bytes, server_details: ServerDetails) -> None:
         handlers: Set[RegisteredListener] = (
             ProtobufEventPayload.HANDLER_LIST.get_handlers(server_details)
         )
@@ -372,5 +369,5 @@ class RustWebsocket:
 
     @staticmethod
     async def run_coroutine_non_blocking(coroutine: Coroutine) -> Task:
-        loop: AbstractEventLoop = asyncio.get_event_loop_policy().get_event_loop()
+        loop: AbstractEventLoop = asyncio.get_event_loop()
         return loop.create_task(coroutine)

{rustplus-6.1.3 → rustplus-6.2.1}/rustplus/rust_api.py

@@ -1,9 +1,9 @@
 import asyncio
 from collections import defaultdict
-from datetime import datetime
+from datetime import datetime, timezone
 from importlib import resources
 from io import BytesIO
-from typing import List, Union
+from typing import List
 import logging
 from PIL import Image
 
@@ -56,10 +56,8 @@ class RustSocket:
     def __init__(
         self,
         server_details: ServerDetails,
-        ratelimiter: Union[RateLimiter, None] = None,
-        command_options: Union[CommandOptions, None] = None,
-        use_fp_proxy: bool = False,
-        use_test_server: bool = False,
+        ratelimiter: RateLimiter | None = None,
+        command_options: CommandOptions | None = None,
         debug: bool = False,
     ) -> None:
         self.server_details = server_details
@@ -80,8 +78,6 @@ class RustSocket:
         self.ws = RustWebsocket(
             self.server_details,
             self.command_options,
-            use_fp_proxy,
-            use_test_server,
             debug,
         )
         self.seq = 1
@@ -143,7 +139,7 @@ class RustSocket:
         while True:
             await asyncio.sleep(1)
 
-    async def get_time(self) -> Union[RustTime, RustError]:
+    async def get_time(self) -> RustTime | RustError:
         """
         Gets the current in-game time from the server.
 
@@ -183,7 +179,7 @@ class RustSocket:
 
         await self.ws.send_message(packet, True)
 
-    async def get_info(self) -> Union[RustInfo, RustError]:
+    async def get_info(self) -> RustInfo | RustError:
         """
         Gets information on the Rust Server
         :return: RustInfo - The info of the server
@@ -200,7 +196,7 @@ class RustSocket:
 
         return RustInfo(response.response.info)
 
-    async def get_team_chat(self) -> Union[List[RustChatMessage], RustError]:
+    async def get_team_chat(self) -> List[RustChatMessage] | RustError:
         """
         Gets the team chat from the server
 
@@ -220,7 +216,7 @@ class RustSocket:
             RustChatMessage(message) for message in response.response.team_chat.messages
         ]
 
-    async def get_team_info(self) -> Union[RustTeamInfo, RustError]:
+    async def get_team_info(self) -> RustTeamInfo | RustError:
         """
         Gets Information on the members of your team
 
@@ -238,7 +234,7 @@ class RustSocket:
 
         return RustTeamInfo(response.response.team_info)
 
-    async def get_markers(self) -> Union[List[RustMarker], RustError]:
+    async def get_markers(self) -> List[RustMarker] | RustError:
         """
         Gets all the map markers from the server
 
@@ -262,9 +258,9 @@ class RustSocket:
         add_events: bool = False,
         add_vending_machines: bool = False,
         add_team_positions: bool = False,
-        override_images: dict = None,
+        override_images: dict | None = None,
         add_grid: bool = False,
-    ) -> Union[Image.Image, RustError]:
+    ) -> Image.Image | RustError:
         """
         Gets an image of the map from the server with the specified additions
 
@@ -308,7 +304,9 @@ class RustSocket:
         output = output.crop(
             (500, 500, map_packet.height - 500, map_packet.width - 500)
         )
-        output = output.resize((map_size, map_size), Image.LANCZOS).convert("RGBA")
+        output = output.resize((map_size, map_size), Image.Resampling.LANCZOS).convert(
+            "RGBA"
+        )
 
         if add_grid:
             output.paste(grid := generate_grid(map_size), (5, 5), grid)
@@ -326,7 +324,7 @@ class RustSocket:
                     if str(monument.token) == "DungeonBase":
                         continue
                     if "underwater-lab-base" in str(monument.token):
-                        # An underwater lab's interior modules (moonpools, etc.) are
+                        # An underwater lab's interior modules (moon pools, etc.) are
                         # reported as separate markers next to the lab; they aren't
                         # standalone monuments, so don't draw them.
                         continue
@@ -387,7 +385,7 @@ class RustSocket:
 
         return output
 
-    async def get_map_info(self) -> Union[RustMap, RustError]:
+    async def get_map_info(self) -> RustMap | RustError:
         """
         Gets the raw map data from the server
 
@@ -405,9 +403,7 @@ class RustSocket:
 
         return RustMap(response.response.map)
 
-    async def get_entity_info(
-        self, eid: int = None
-    ) -> Union[RustEntityInfo, RustError]:
+    async def get_entity_info(self, eid: int) -> RustEntityInfo | RustError:
         """
         Gets entity info from the server
 
@@ -459,7 +455,7 @@ class RustSocket:
 
         await self.ws.send_message(packet, True)
 
-    async def check_subscription_to_entity(self, eid: int) -> Union[bool, RustError]:
+    async def check_subscription_to_entity(self, eid: int) -> bool | RustError:
         """
         Checks if you are subscribed to an entity
 
@@ -481,7 +477,7 @@ class RustSocket:
 
         return response.response.flag.value
 
-    async def promote_to_team_leader(self, steamid: int = None) -> None:
+    async def promote_to_team_leader(self, steamid: int) -> None:
         """
         Promotes a given user to the team leader by their 64-bit Steam ID
 
@@ -496,8 +492,8 @@ class RustSocket:
         await self.ws.send_message(packet, True)
 
     async def get_contents(
-        self, eid: int = None, combine_stacks: bool = False
-    ) -> Union[RustContents, RustError]:
+        self, eid: int, combine_stacks: bool = False
+    ) -> RustContents | RustError:
         """
         Gets the contents of a storage monitor-attached container
 
@@ -510,8 +506,10 @@ class RustSocket:
         if isinstance(returned_data, RustError):
             return returned_data
 
-        target_time = datetime.utcfromtimestamp(int(returned_data.protection_expiry))
-        difference = target_time - datetime.utcnow()
+        target_time = datetime.fromtimestamp(
+            int(returned_data.protection_expiry), tz=timezone.utc
+        )
+        difference = target_time - datetime.now(timezone.utc)
 
         items = []
 
@@ -552,13 +550,13 @@ class RustSocket:
 
         return RustContents(difference, bool(returned_data.has_protection), items)
 
-    async def get_camera_manager(self, cam_id: str) -> Union[CameraManager, RustError]:
+    async def get_camera_manager(self, cam_id: str) -> CameraManager | RustError:
         """
         Gets a camera manager for a given camera ID
 
         NOTE: This will override the current camera manager if one exists for the given ID so you cannot have multiple
 
-        :param cam_id: The ID of the camera
+        :param cam_id: The ID of the target camera
         :return CameraManager: The camera manager
         :raises RequestError: If the camera is not found, or you cannot access it. See reason for more info
         """
@@ -576,7 +574,7 @@ class RustSocket:
 
         return CameraManager(self, cam_id, response.response.camera_subscribe_info)
 
-    async def get_clan_info(self) -> Union[RustClanInfo, RustError]:
+    async def get_clan_info(self) -> RustClanInfo | RustError:
         """
         Gets the clan information for the player's current clan.
 
@@ -594,7 +592,7 @@ class RustSocket:
 
         return RustClanInfo(response.response.clan_info.clan_info)
 
-    async def get_clan_chat(self) -> Union[List[RustClanMessage], RustError]:
+    async def get_clan_chat(self) -> List[RustClanMessage] | RustError:
         """
         Gets the clan chat for the player's current clan.
 
@@ -642,7 +640,7 @@ class RustSocket:
 
         await self.ws.send_message(packet, True)
 
-    async def get_nexus_auth(self, app_key: str) -> Union[RustAuthDetails, RustError]:
+    async def get_nexus_auth(self, app_key: str) -> RustAuthDetails | RustError:
         """
         Gets the auth for a server. Does not require that the player token of this RustSocket is set correctly.
 
@@ -667,7 +665,7 @@ class RustSocket:
             response.response.nexus_auth.player_token,
         )
 
-    async def kick_from_team(self, steamid: int) -> Union[None, RustError]:
+    async def kick_from_team(self, steamid: int) -> None | RustError:
         """
         Kicks a player from the team by their 64-bit Steam ID
 

{rustplus-6.1.3 → rustplus-6.2.1}/rustplus/structs/rust_chat_message.py

@@ -1,10 +1,9 @@
-from typing import Union
 from ..remote.rustplus_proto import AppTeamMessage, AppClanMessage
 from .serialization import Serializable
 
 
 class RustChatMessage(Serializable):
-    def __init__(self, data: Union[AppTeamMessage, AppClanMessage]):
+    def __init__(self, data: AppTeamMessage | AppClanMessage):
         self._steam_id: int = data.steam_id
         self._name: str = data.name
         self._message: str = data.message

{rustplus-6.1.3 → rustplus-6.2.1}/rustplus/structs/rust_item.py

@@ -1,10 +1,9 @@
-from typing import Union
 from .serialization import Serializable
 
 
 class RustItem(Serializable):
     def __init__(
-        self, name: str, item_id: Union[str, int], quantity: int, is_blueprint: bool
+        self, name: str, item_id: str | int, quantity: int, is_blueprint: bool
     ) -> None:
         self._name: str = name
         self._item_id: int = int(item_id)