rustplus 5.6.17__tar.gz → 6.0.0__tar.gz

rustplus-6.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+recursive-include rustplus *.png
+recursive-include rustplus *.ttf
+include requirements.txt

{rustplus-5.6.17/rustplus.egg-info → rustplus-6.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rustplus
-Version: 5.6.17
+Version: 6.0.0
 Summary: A python wrapper for the Rust Plus API
 Home-page: https://github.com/olijeffers0n/rustplus
 Author: olijeffers0n
@@ -12,7 +12,7 @@ License-File: LICENSE
 Requires-Dist: websockets
 Requires-Dist: Pillow
 Requires-Dist: asyncio
-Requires-Dist: rustPlusPushReceiver==0.4.1
+Requires-Dist: rustPlusPushReceiver==0.6.0
 Requires-Dist: http-ece
 Requires-Dist: requests
 Requires-Dist: numpy

rustplus-6.0.0/requirements.txt

@@ -0,0 +1,9 @@
+websockets
+Pillow
+asyncio
+rustPlusPushReceiver==0.6.0
+http-ece
+requests
+numpy
+scipy
+betterproto==2.0.0b6

rustplus-6.0.0/rustplus/__init__.py

@@ -0,0 +1,16 @@
+r"""
+RustPlus, An API wrapper for interfacing with the Rust+ App API
+"""
+
+from .rust_api import RustSocket
+from .identification import ServerDetails
+from .annotations import Command, ChatEvent, ProtobufEvent, TeamEvent, EntityEvent
+from .remote.fcm import FCMListener
+from .commands import CommandOptions, ChatCommand
+from .events import ChatEventPayload, TeamEventPayload, EntityEventPayload
+from .utils import convert_event_type_to_name, Emoji
+
+__name__ = "rustplus"
+__author__ = "olijeffers0n"
+__version__ = "6.0.0"
+__support__ = "Discord: https://discord.gg/nQqJe8qvP8"

rustplus-6.0.0/rustplus/annotations/__init__.py

@@ -0,0 +1,5 @@
+from .command import Command
+from .entity_event import EntityEvent
+from .chat_event import ChatEvent
+from .team_event import TeamEvent
+from .protobuf_event import ProtobufEvent

rustplus-6.0.0/rustplus/annotations/chat_event.py

@@ -0,0 +1,21 @@
+from typing import Callable
+
+from .. import ServerDetails
+from ..identification import RegisteredListener
+from ..events import ChatEventPayload as ChatEventManager
+
+
+def ChatEvent(server_details: ServerDetails) -> Callable:
+
+    def wrapper(func) -> RegisteredListener:
+
+        if isinstance(func, RegisteredListener):
+            func = func.get_coro()
+
+        listener = RegisteredListener(func.__name__, func)
+
+        ChatEventManager.HANDLER_LIST.register(listener, server_details)
+
+        return listener
+
+    return wrapper

rustplus-6.0.0/rustplus/annotations/command.py

@@ -0,0 +1,23 @@
+from typing import Callable
+
+from ..identification import RegisteredListener, ServerDetails
+from ..commands import ChatCommand, ChatCommandData
+
+
+def Command(
+    server_details: ServerDetails, aliases: list = None, alias_func: Callable = None
+) -> Callable:
+
+    def wrapper(func):
+
+        if isinstance(func, RegisteredListener):
+            func = func.get_coro()
+
+        command_data = ChatCommandData(
+            coroutine=func, aliases=aliases, callable_func=alias_func
+        )
+        ChatCommand.REGISTERED_COMMANDS[server_details][func.__name__] = command_data
+
+        return RegisteredListener(func.__name__, func)
+
+    return wrapper

rustplus-6.0.0/rustplus/annotations/entity_event.py

@@ -0,0 +1,19 @@
+from typing import Callable
+
+from .. import ServerDetails
+from ..identification import RegisteredListener
+from ..events import EntityEventPayload as EntityEventManager
+
+
+def EntityEvent(server_details: ServerDetails, eid: int) -> Callable:
+    def wrapper(func) -> RegisteredListener:
+        if isinstance(func, RegisteredListener):
+            func = func.get_coro()
+
+        listener = RegisteredListener(str(eid), func)
+
+        EntityEventManager.HANDLER_LIST.register(listener, server_details)
+
+        return listener
+
+    return wrapper

rustplus-6.0.0/rustplus/annotations/protobuf_event.py

@@ -0,0 +1,19 @@
+from typing import Callable
+
+from .. import ServerDetails
+from ..identification import RegisteredListener
+from ..events import ProtobufEventPayload as ProtobufEventManager
+
+
+def ProtobufEvent(server_details: ServerDetails) -> Callable:
+    def wrapper(func) -> RegisteredListener:
+        if isinstance(func, RegisteredListener):
+            func = func.get_coro()
+
+        listener = RegisteredListener(func.__name__, func)
+
+        ProtobufEventManager.HANDLER_LIST.register(listener, server_details)
+
+        return listener
+
+    return wrapper

rustplus-6.0.0/rustplus/annotations/team_event.py

@@ -0,0 +1,19 @@
+from typing import Callable
+
+from .. import ServerDetails
+from ..identification import RegisteredListener
+from ..events import TeamEventPayload as TeamEventManager
+
+
+def TeamEvent(server_details: ServerDetails) -> Callable:
+    def wrapper(func) -> RegisteredListener:
+        if isinstance(func, RegisteredListener):
+            func = func.get_coro()
+
+        listener = RegisteredListener(func.__name__, func)
+
+        TeamEventManager.HANDLER_LIST.register(listener, server_details)
+
+        return listener
+
+    return wrapper

rustplus-6.0.0/rustplus/commands/__init__.py

@@ -0,0 +1,3 @@
+from .chat_command_data import ChatCommandData
+from .chat_command import ChatCommand, ChatCommandTime
+from .command_options import CommandOptions

rustplus-6.0.0/rustplus/commands/chat_command.py

@@ -0,0 +1,33 @@
+import dataclasses
+from collections import defaultdict
+from typing import Dict, List
+
+from .chat_command_data import ChatCommandData
+from ..identification import ServerDetails
+
+
+@dataclasses.dataclass
+class ChatCommandTime:
+    formatted_time: str
+    raw_time: int
+
+
+class ChatCommand:
+
+    REGISTERED_COMMANDS: Dict[ServerDetails, Dict[str, ChatCommandData]] = defaultdict(
+        dict
+    )
+
+    def __init__(
+        self,
+        sender_name: str,
+        sender_steam_id: int,
+        time: ChatCommandTime,
+        command: str,
+        args: List[str],
+    ) -> None:
+        self.sender_name = sender_name
+        self.sender_steam_id = sender_steam_id
+        self.time = time
+        self.command = command
+        self.args = args

rustplus-5.6.17/rustplus/commands/command_data.py → rustplus-6.0.0/rustplus/commands/chat_command_data.py

@@ -1,21 +1,22 @@
-from typing import Callable, List
+from typing import Callable
 
 
-class CommandData:
-    def __init__(self, coro, aliases, callable_func) -> None:
-        self.coro = coro
+class ChatCommandData:
+
+    def __init__(self, coroutine: Callable, aliases=None, callable_func=None) -> None:
+        self.coroutine = coroutine
         self._aliases = aliases
         self._callable_func = callable_func
 
     @property
-    def aliases(self) -> List[str]:
+    def aliases(self):
         if self._aliases is None:
             return []
 
         return self._aliases
 
     @property
-    def callable_func(self) -> Callable:
+    def callable_func(self):
         if self._callable_func is None:
             return lambda x: False
 

rustplus-6.0.0/rustplus/commands/command_options.py

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

rustplus-6.0.0/rustplus/events/__init__.py

@@ -0,0 +1,4 @@
+from .chat_event import ChatEventPayload
+from .entity_event import EntityEventPayload
+from .team_event import TeamEventPayload
+from .protobuf_event import ProtobufEventPayload

rustplus-6.0.0/rustplus/events/chat_event.py

@@ -0,0 +1,13 @@
+from rustplus.identification.handler_list import HandlerList
+from ..structs import RustChatMessage
+
+
+class ChatEventPayload:
+    HANDLER_LIST = HandlerList()
+
+    def __init__(self, message: RustChatMessage) -> None:
+        self._message = message
+
+    @property
+    def message(self) -> RustChatMessage:
+        return self._message

rustplus-6.0.0/rustplus/events/entity_event.py

@@ -0,0 +1,60 @@
+from typing import List
+
+from rustplus.identification.handler_list import EntityHandlerList
+from ..remote.rustplus_proto import AppEntityPayloadItem, AppEntityChanged
+
+
+class Item:
+    def __init__(self, app_message: AppEntityPayloadItem) -> None:
+        self._item_id: int = app_message.item_id
+        self._quantity: int = app_message.quantity
+        self._item_is_blueprint: bool = app_message.item_is_blueprint
+
+    @property
+    def item_id(self) -> int:
+        return self._item_id
+
+    @property
+    def quantity(self) -> int:
+        return self._quantity
+
+    @property
+    def item_is_blueprint(self) -> bool:
+        return self._item_is_blueprint
+
+
+class EntityEventPayload:
+    HANDLER_LIST = EntityHandlerList()
+
+    def __init__(self, entity_changed: AppEntityChanged) -> None:
+        self._entity_id: int = entity_changed.entity_id
+        self._value: bool = entity_changed.payload.value
+        self._capacity: int = entity_changed.payload.capacity
+        self._has_protection: bool = entity_changed.payload.has_protection
+        self._protection_expiry: int = entity_changed.payload.protection_expiry
+
+        self._items: List[Item] = [Item(item) for item in entity_changed.payload.items]
+
+    @property
+    def entity_id(self) -> int:
+        return self._entity_id
+
+    @property
+    def value(self) -> bool:
+        return self._value
+
+    @property
+    def capacity(self) -> int:
+        return self._capacity
+
+    @property
+    def has_protection(self) -> bool:
+        return self._has_protection
+
+    @property
+    def protection_expiry(self) -> int:
+        return self._protection_expiry
+
+    @property
+    def items(self) -> List[Item]:
+        return self._items

rustplus-6.0.0/rustplus/events/protobuf_event.py

@@ -0,0 +1,12 @@
+from rustplus.identification.handler_list import HandlerList
+
+
+class ProtobufEventPayload:
+    HANDLER_LIST = HandlerList()
+
+    def __init__(self, message: bytes) -> None:
+        self._message = message
+
+    @property
+    def message(self) -> bytes:
+        return self._message

rustplus-6.0.0/rustplus/events/team_event.py

@@ -0,0 +1,18 @@
+from rustplus.identification.handler_list import HandlerList
+from ..structs import RustTeamInfo
+
+
+class TeamEventPayload:
+    HANDLER_LIST = HandlerList()
+
+    def __init__(self, player_id: int, team_info: RustTeamInfo) -> None:
+        self._player_id = player_id
+        self._team_info = team_info
+
+    @property
+    def player_id(self) -> int:
+        return self._player_id
+
+    @property
+    def team_info(self) -> RustTeamInfo:
+        return self._team_info

rustplus-6.0.0/rustplus/identification/__init__.py

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

rustplus-6.0.0/rustplus/identification/handler_list.py

@@ -0,0 +1,76 @@
+from collections import defaultdict
+from typing import Set, Dict
+from rustplus.identification import (
+    RegisteredListener,
+    ServerDetails,
+)
+
+
+class HandlerList:
+    def __init__(self) -> None:
+        self._handlers: Dict[ServerDetails, Set[RegisteredListener]] = defaultdict(set)
+
+    def unregister(
+        self, listener: RegisteredListener, server_details: ServerDetails
+    ) -> None:
+        self._handlers[server_details].remove(listener)
+
+    def register(
+        self, listener: RegisteredListener, server_details: ServerDetails
+    ) -> None:
+        self._handlers[server_details].add(listener)
+
+    def has(self, listener: RegisteredListener, server_details: ServerDetails) -> bool:
+        return listener in self._handlers[server_details]
+
+    def unregister_all(self) -> None:
+        self._handlers.clear()
+
+    def get_handlers(self, server_details: ServerDetails) -> Set[RegisteredListener]:
+        return self._handlers.get(server_details, set())
+
+
+class EntityHandlerList(HandlerList):
+    def __init__(self) -> None:
+        super().__init__()
+        self._handlers: Dict[ServerDetails, Dict[str, Set[RegisteredListener]]] = (
+            defaultdict(dict)
+        )
+
+    def unregister(
+        self, listener: RegisteredListener, server_details: ServerDetails
+    ) -> None:
+        if listener.listener_id in self._handlers.get(server_details):
+            self._handlers.get(server_details).get(listener.listener_id).remove(
+                listener
+            )
+
+    def register(
+        self, listener: RegisteredListener, server_details: ServerDetails
+    ) -> None:
+        if server_details not in self._handlers:
+            self._handlers[server_details] = defaultdict(set)
+
+        if listener.listener_id not in self._handlers.get(server_details):
+            self._handlers.get(server_details)[listener.listener_id] = set()
+
+        self._handlers.get(server_details).get(listener.listener_id).add(listener)
+
+    def has(self, listener: RegisteredListener, server_details: ServerDetails) -> bool:
+        if (
+            server_details in self._handlers
+            and listener.listener_id in self._handlers.get(server_details)
+        ):
+            return listener in self._handlers.get(server_details).get(
+                listener.listener_id
+            )
+
+        return False
+
+    def unregister_all(self) -> None:
+        self._handlers.clear()
+
+    def get_handlers(
+        self, server_details: ServerDetails
+    ) -> Dict[str, Set[RegisteredListener]]:
+        return self._handlers.get(server_details, dict())

{rustplus-5.6.17/rustplus/api/remote/events → rustplus-6.0.0/rustplus/identification}/registered_listener.py

@@ -1,23 +1,18 @@
-from typing import Union, Coroutine
+from typing import Coroutine
 
 
 class RegisteredListener:
     def __init__(
         self,
-        listener_id: Union[str, int],
+        listener_id: str,
         coroutine: Coroutine,
-        entity_type: int = None,
     ) -> None:
-        self.listener_id = str(listener_id)
+        self.listener_id = listener_id
         self._coroutine = coroutine
-        self._entity_type = entity_type
 
     def get_coro(self):
         return self._coroutine
 
-    def get_entity_type(self):
-        return self._entity_type
-
     def __eq__(self, other) -> bool:
         if not isinstance(other, RegisteredListener):
             return False
@@ -25,8 +20,7 @@ class RegisteredListener:
         return (
             self.listener_id == other.listener_id
             and self._coroutine == other.get_coro()
-            and self._entity_type == other.get_entity_type()
         )
 
     def __hash__(self):
-        return hash((self.listener_id, self._coroutine, self._entity_type))
+        return hash((self.listener_id, self._coroutine))

rustplus-6.0.0/rustplus/identification/server_details.py

@@ -0,0 +1,39 @@
+from typing import Union
+
+
+class ServerDetails:
+    def __init__(
+        self,
+        ip: str,
+        port: Union[str, int, None],
+        player_id: int,
+        player_token: int,
+        secure: bool = False,
+    ) -> None:
+        self.ip = str(ip)
+        self.port = str(port)
+        self.player_id = int(player_id)
+        self.player_token = int(player_token)
+        self.secure = secure
+
+    def get_server_string(self) -> str:
+        if self.port is None:
+            return f"{self.ip}"
+        return f"{self.ip}:{self.port}"
+
+    def __str__(self) -> str:
+        return f"{self.ip}:{self.port} {self.player_id} {self.player_token}"
+
+    def __hash__(self):
+        return hash(self.__str__())
+
+    def __eq__(self, o: object) -> bool:
+        if not isinstance(o, ServerDetails):
+            return False
+
+        return (
+            self.ip == o.ip
+            and self.port == o.port
+            and self.player_id == o.player_id
+            and self.player_token == o.player_token
+        )

{rustplus-5.6.17/rustplus/api → rustplus-6.0.0/rustplus}/remote/camera/camera_manager.py

@@ -1,6 +1,5 @@
 import time
 from typing import Iterable, Union, List, Coroutine, Set, Callable
-
 from PIL import Image
 
 from .camera_parser import Parser
@@ -10,12 +9,17 @@ from ..rustplus_proto import (
     AppEmpty,
     AppRequest,
     AppCameraInfo,
+    AppCameraRays,
+    AppCameraSubscribe,
 )
-from ...structures import Vector
+from ...structs import Vector
 from .structures import CameraInfo, Entity, LimitedQueue
 
 
 class CameraManager:
+
+    ACTIVE_INSTANCE: Union["CameraManager", None] = None
+
     def __init__(
         self, rust_socket, cam_id: str, cam_info_message: AppCameraInfo
     ) -> None:
@@ -29,8 +33,9 @@ class CameraManager:
         )
         self.time_since_last_subscribe: float = time.time()
         self.frame_callbacks: Set[Callable[[Image.Image], Coroutine]] = set()
+        CameraManager.ACTIVE_INSTANCE = self
 
-    async def add_packet(self, packet) -> None:
+    async def add_packet(self, packet: AppCameraRays) -> None:
         self._last_packets.add(packet)
 
         if len(self.frame_callbacks) == 0:
@@ -122,8 +127,7 @@ class CameraManager:
         for movement in movements:
             value = value | movement
 
-        await self.rust_socket._handle_ratelimit(0.01)
-        app_request: AppRequest = self.rust_socket._generate_protobuf()
+        app_request: AppRequest = await self.rust_socket._generate_request(0.01)
         cam_input = AppCameraInput()
 
         cam_input.buttons = value
@@ -133,25 +137,29 @@ class CameraManager:
         cam_input.mouse_delta = vector
         app_request.camera_input = cam_input
 
-        await self.rust_socket.remote.send_message(app_request)
-        await self.rust_socket.remote.add_ignored_response(app_request.seq)
+        await self.rust_socket.ws.send_message(app_request, True)
 
     async def exit_camera(self) -> None:
-        await self.rust_socket._handle_ratelimit()
-        app_request: AppRequest = self.rust_socket._generate_protobuf()
+        app_request: AppRequest = await self.rust_socket._generate_request()
         app_request.camera_unsubscribe = AppEmpty()
 
-        await self.rust_socket.remote.send_message(app_request)
-        await self.rust_socket.remote.add_ignored_response(app_request.seq)
+        await self.rust_socket.ws.send_message(app_request, True)
 
         self._open = False
         self._last_packets.clear()
 
     async def resubscribe(self) -> None:
-        await self.rust_socket.remote.subscribe_to_camera(self._cam_id, True)
+
+        packet = await self.rust_socket._generate_request()
+        subscribe = AppCameraSubscribe()
+        subscribe.camera_id = self._cam_id
+        packet.camera_subscribe = subscribe
+
+        self.rust_socket.ws.send_message(packet, True)
+
         self.time_since_last_subscribe = time.time()
         self._open = True
-        self.rust_socket.remote.camera_manager = self
+        self.ACTIVE_INSTANCE = self
 
     async def get_entities_in_frame(self) -> List[Entity]:
         if self._last_packets is None:

{rustplus-5.6.17/rustplus/api → rustplus-6.0.0/rustplus}/remote/camera/camera_parser.py

@@ -318,9 +318,9 @@ class Parser:
         entity_size = np.array([entity.size.x, entity.size.y, entity.size.z, 0])
 
         vertices = (
-            MathUtils.get_player_vertices(entity.size)
+            MathUtils.get_player_vertices(Vector3(vector3=entity.size))
             if entity.type == 2
-            else MathUtils.get_tree_vertices(entity.size)
+            else MathUtils.get_tree_vertices(Vector3(vector3=entity.size))
         )
         # Add the position for the name tag to the vertices
         vertices = np.append(vertices, [np.array([0, 1.3, 0, 1])], axis=0)
@@ -367,7 +367,9 @@ class Parser:
         colour = (
             (PLAYER_COLOUR if not entity.name.isdigit() else SCIENTIST_COLOUR)
             if entity.type == 2
-            else MathUtils.get_slightly_random_colour(TREE_COLOUR, entity.position)
+            else MathUtils.get_slightly_random_colour(
+                TREE_COLOUR, Vector3(vector3=entity.position)
+            )
         )
 
         MathUtils.set_polygon_with_depth(
@@ -393,11 +395,12 @@ class Parser:
             # The font size should be proportional to the size of the entity as it gets further away
             with resources.path(FONT_PATH, "PermanentMarker.ttf") as path:
                 font = ImageFont.truetype(str(path), font_size)
-            size = image_draw.textsize(entity.name, font=font)
+            width = image_draw.textlength(entity.name, font=font)
+            height = font_size
 
             name_place1 = (
-                name_place[0] - size[0] // 2,
-                name_place[1] - size[1] // 2,
+                name_place[0] - width // 2,
+                name_place[1] - height // 2,
             )
             text.add((name_place1, entity.name, font))