rustplus 6.0.2__tar.gz → 6.0.3__tar.gz

{rustplus-6.0.2/rustplus.egg-info → rustplus-6.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rustplus
-Version: 6.0.2
+Version: 6.0.3
 Summary: A python wrapper for the Rust Plus API
 Home-page: https://github.com/olijeffers0n/rustplus
 Author: olijeffers0n

{rustplus-6.0.2 → rustplus-6.0.3}/rustplus/__init__.py

@@ -9,8 +9,9 @@ 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
+from .structs import RustError, RustMarker
 
 __name__ = "rustplus"
 __author__ = "olijeffers0n"
-__version__ = "6.0.2"
+__version__ = "6.0.3"
 __support__ = "Discord: https://discord.gg/nQqJe8qvP8"

{rustplus-6.0.2 → rustplus-6.0.3}/rustplus/remote/websocket/ws.py

@@ -11,7 +11,7 @@ import asyncio
 
 from ..camera import CameraManager
 from ..proxy import ProxyValueGrabber
-from ..rustplus_proto import AppMessage, AppRequest
+from ..rustplus_proto import AppMessage, AppRequest, AppError
 from ...commands import CommandOptions, ChatCommand, ChatCommandTime
 from ...events import (
     ProtobufEventPayload,
@@ -19,10 +19,11 @@ from ...events import (
     TeamEventPayload,
     ChatEventPayload,
 )
-from ...exceptions import ClientNotConnectedError, RequestError
+from ...exceptions import RequestError
 from ...identification import ServerDetails, RegisteredListener
 from ...structs import RustChatMessage, RustTeamInfo
 from ...utils import YieldingEvent, convert_time
+from ...utils.utils import error_present
 
 
 class RustWebsocket:
@@ -133,14 +134,21 @@ class RustWebsocket:
                 )
 
     async def send_and_get(self, request: AppRequest) -> AppMessage:
-        await self.send_message(request)
+        if not await self.send_message(request):
+            message = AppMessage()
+            error = AppError()
+            error.error = "Message Failed to send"
+            message.response.seq = request.seq
+            message.response.error = error
+            return message
         return await self.get_response(request.seq)
 
     async def send_message(
         self, request: AppRequest, ignore_response: bool = False
-    ) -> None:
+    ) -> bool:
         if self.connection is None:
-            raise ClientNotConnectedError("No Current Websocket Connection")
+            self.logger.warning("No Current Websocket Connection")
+            return False
 
         if self.debug:
             self.logger.info(f"Sending Message with seq {request.seq}: {request}")
@@ -157,6 +165,9 @@ class RustWebsocket:
                 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]:
 
@@ -171,8 +182,18 @@ class RustWebsocket:
                 f"Received Message with seq {app_message.response.seq}: {app_message}"
             )
 
-        if self.error_present(app_message.response.error.error):
-            raise RequestError(app_message.response.error.error)
+        if error_present(app_message):
+
+            event: YieldingEvent = self.responses.get(app_message.response.seq, None)
+            if event is not None:
+                if self.debug:
+                    self.logger.info(
+                        f"Running Response Event With Error: {app_message}"
+                    )
+
+                event.set_with_value(app_message)
+            else:
+                raise RequestError(app_message.response.error.error)
 
         prefix = self.get_prefix(
             str(app_message.broadcast.team_message.message.message)
@@ -335,13 +356,6 @@ class RustWebsocket:
 
         raise ValueError()
 
-    @staticmethod
-    def error_present(message) -> bool:
-        """
-        Checks message for error
-        """
-        return message != ""
-
     @staticmethod
     async def run_coroutine_non_blocking(coroutine: Coroutine) -> Task:
         loop: AbstractEventLoop = asyncio.get_event_loop_policy().get_event_loop()

{rustplus-6.0.2 → rustplus-6.0.3}/rustplus/rust_api.py

@@ -32,6 +32,7 @@ from .structs import (
     RustContents,
     RustItem,
 )
+from .structs.rust_error import RustError
 from .utils import (
     convert_time,
     translate_id_to_stack,
@@ -42,6 +43,7 @@ from .utils import (
     convert_monument,
 )
 from .remote.ratelimiter import RateLimiter
+from .utils.utils import error_present
 
 
 class RustSocket:
@@ -127,13 +129,13 @@ class RustSocket:
         This Will permanently put your script into a state of 'hanging' Cannot be Undone. Only do this in scripts
         using commands
 
-        :returns Nothing, This will never return
+        returns Nothing, This will never return
         """
 
         while True:
             await asyncio.sleep(1)
 
-    async def get_time(self) -> Union[RustTime, None]:
+    async def get_time(self) -> Union[RustTime, RustError]:
         """
         Gets the current in-game time from the server.
 
@@ -142,18 +144,21 @@ class RustSocket:
 
         packet = await self._generate_request()
         packet.get_time = AppEmpty()
-        packet = await self.ws.send_and_get(packet)
+        response = await self.ws.send_and_get(packet)
+
+        if response is None:
+            return RustError("get_time", "misc")
 
-        if packet is None:
-            return None
+        if error_present(response):
+            return RustError("get_time", response.response.error.error)
 
         return RustTime(
-            packet.response.time.day_length_minutes,
-            convert_time(packet.response.time.sunrise),
-            convert_time(packet.response.time.sunset),
-            convert_time(packet.response.time.time),
-            packet.response.time.time,
-            packet.response.time.time_scale,
+            response.response.time.day_length_minutes,
+            convert_time(response.response.time.sunrise),
+            convert_time(response.response.time.sunset),
+            convert_time(response.response.time.time),
+            response.response.time.time,
+            response.response.time.time_scale,
         )
 
     async def send_team_message(self, message: str) -> None:
@@ -170,21 +175,24 @@ class RustSocket:
 
         await self.ws.send_message(packet, True)
 
-    async def get_info(self) -> Union[RustInfo, None]:
+    async def get_info(self) -> Union[RustInfo, RustError]:
         """
         Gets information on the Rust Server
         :return: RustInfo - The info of the server
         """
         packet = await self._generate_request()
         packet.get_info = AppEmpty()
-
         response = await self.ws.send_and_get(packet)
+
         if response is None:
-            return None
+            return RustError("get_info", "misc")
+
+        if error_present(response):
+            return RustError("get_info", response.response.error.error)
 
         return RustInfo(response.response.info)
 
-    async def get_team_chat(self) -> Union[List[RustChatMessage], None]:
+    async def get_team_chat(self) -> Union[List[RustChatMessage], RustError]:
         """
         Gets the team chat from the server
 
@@ -192,16 +200,19 @@ class RustSocket:
         """
         packet = await self._generate_request()
         packet.get_team_chat = AppEmpty()
-
         response = await self.ws.send_and_get(packet)
+
         if response is None:
-            return None
+            return RustError("get_team_chat", "misc")
+
+        if error_present(response):
+            return RustError("get_team_chat", response.response.error.error)
 
         return [
             RustChatMessage(message) for message in response.response.team_chat.messages
         ]
 
-    async def get_team_info(self) -> Union[RustTeamInfo, None]:
+    async def get_team_info(self) -> Union[RustTeamInfo, RustError]:
         """
         Gets Information on the members of your team
 
@@ -209,14 +220,17 @@ class RustSocket:
         """
         packet = await self._generate_request()
         packet.get_team_info = AppEmpty()
-
         response = await self.ws.send_and_get(packet)
+
         if response is None:
-            return None
+            return RustError("get_team_info", "misc")
+
+        if error_present(response):
+            return RustError("get_team_info", response.response.error.error)
 
         return RustTeamInfo(response.response.team_info)
 
-    async def get_markers(self) -> Union[List[RustMarker], None]:
+    async def get_markers(self) -> Union[List[RustMarker], RustError]:
         """
         Gets all the map markers from the server
 
@@ -224,10 +238,13 @@ class RustSocket:
         """
         packet = await self._generate_request()
         packet.get_map_markers = AppEmpty()
-
         response = await self.ws.send_and_get(packet)
+
         if response is None:
-            return None
+            return RustError("get_markers", "misc")
+
+        if error_present(response):
+            return RustError("get_markers", response.response.error.error)
 
         return [RustMarker(marker) for marker in response.response.map_markers.markers]
 
@@ -239,7 +256,7 @@ class RustSocket:
         add_team_positions: bool = False,
         override_images: dict = None,
         add_grid: bool = False,
-    ) -> Union[Image.Image, None]:
+    ) -> Union[Image.Image, RustError]:
         """
         Gets an image of the map from the server with the specified additions
 
@@ -256,16 +273,20 @@ class RustSocket:
             override_images = {}
 
         server_info = await self.get_info()
-        if server_info is None:
-            return None
+        if isinstance(server_info, RustError):
+            return server_info
 
         map_size = server_info.size
 
         packet = await self._generate_request(5)
         packet.get_map = AppEmpty()
         response = await self.ws.send_and_get(packet)
+
         if response is None:
-            return None
+            return RustError("get_map", "misc")
+
+        if error_present(response):
+            return RustError("get_map", response.response.error.error)
 
         map_packet = response.response.map
         monuments: List[AppMapMonument] = map_packet.monuments
@@ -274,7 +295,7 @@ class RustSocket:
             output = Image.open(BytesIO(map_packet.jpg_image))
         except Exception as e:
             self.logger.error(f"Error opening image: {e}")
-            return None
+            return RustError("get_map", str(e))
 
         output = output.crop(
             (500, 500, map_packet.height - 500, map_packet.width - 500)
@@ -349,7 +370,7 @@ class RustSocket:
 
         return output
 
-    async def get_map_info(self) -> Union[RustMap, None]:
+    async def get_map_info(self) -> Union[RustMap, RustError]:
         """
         Gets the raw map data from the server
 
@@ -357,14 +378,19 @@ class RustSocket:
         """
         packet = await self._generate_request(tokens=5)
         packet.get_map = AppEmpty()
-
         response = await self.ws.send_and_get(packet)
+
         if response is None:
-            return None
+            return RustError("get_map_info", "misc")
+
+        if error_present(response):
+            return RustError("get_map_info", response.response.error.error)
 
         return RustMap(response.response.map)
 
-    async def get_entity_info(self, eid: int = None) -> Union[RustEntityInfo, None]:
+    async def get_entity_info(
+        self, eid: int = None
+    ) -> Union[RustEntityInfo, RustError]:
         """
         Gets entity info from the server
 
@@ -374,10 +400,13 @@ class RustSocket:
         packet = await self._generate_request()
         packet.get_entity_info = AppEmpty()
         packet.entity_id = eid
-
         response = await self.ws.send_and_get(packet)
+
         if response is None:
-            return None
+            return RustError("get_entity_info", "misc")
+
+        if error_present(response):
+            return RustError("get_entity_info", response.response.error.error)
 
         return RustEntityInfo(response.response.entity_info)
 
@@ -413,7 +442,7 @@ class RustSocket:
 
         await self.ws.send_message(packet, True)
 
-    async def check_subscription_to_entity(self, eid: int) -> Union[bool, None]:
+    async def check_subscription_to_entity(self, eid: int) -> Union[bool, RustError]:
         """
         Checks if you are subscribed to an entity
 
@@ -423,10 +452,15 @@ class RustSocket:
         packet = await self._generate_request()
         packet.check_subscription = AppEmpty()
         packet.entity_id = eid
-
         response = await self.ws.send_and_get(packet)
+
         if response is None:
-            return None
+            return RustError("check_subscription_to_entity", "misc")
+
+        if error_present(response):
+            return RustError(
+                "check_subscription_to_entity", response.response.error.error
+            )
 
         return response.response.flag.value
 
@@ -446,7 +480,7 @@ class RustSocket:
 
     async def get_contents(
         self, eid: int = None, combine_stacks: bool = False
-    ) -> Union[RustContents, None]:
+    ) -> Union[RustContents, RustError]:
         """
         Gets the contents of a storage monitor-attached container
 
@@ -456,8 +490,8 @@ class RustSocket:
         """
         returned_data = await self.get_entity_info(eid)
 
-        if returned_data is None:
-            return None
+        if isinstance(returned_data, RustError):
+            return returned_data
 
         target_time = datetime.utcfromtimestamp(int(returned_data.protection_expiry))
         difference = target_time - datetime.utcnow()
@@ -501,7 +535,7 @@ class RustSocket:
 
         return RustContents(difference, bool(returned_data.has_protection), items)
 
-    async def get_camera_manager(self, cam_id: str) -> Union[CameraManager, None]:
+    async def get_camera_manager(self, cam_id: str) -> Union[CameraManager, RustError]:
         """
         Gets a camera manager for a given camera ID
 
@@ -515,10 +549,12 @@ class RustSocket:
         subscribe = AppCameraSubscribe()
         subscribe.camera_id = cam_id
         packet.camera_subscribe = subscribe
-
         response = await self.ws.send_and_get(packet)
 
         if response is None:
-            return None
+            return RustError("get_camera_manager", "misc")
+
+        if error_present(response):
+            return RustError("get_camera_manager", response.response.error.error)
 
         return CameraManager(self, cam_id, response.response.camera_subscribe_info)

{rustplus-6.0.2 → rustplus-6.0.3}/rustplus/structs/__init__.py

@@ -8,3 +8,4 @@ from .rust_entity_info import RustEntityInfo
 from .rust_contents import RustContents
 from .rust_item import RustItem
 from .util import Vector
+from .rust_error import RustError

rustplus-6.0.3/rustplus/structs/rust_error.py

@@ -0,0 +1,19 @@
+from .serialization import Serializable
+
+
+class RustError(Serializable):
+
+    def __init__(self, method: str, reason: str) -> None:
+        self._method = method
+        self._reason = reason
+
+    @property
+    def method(self) -> str:
+        return self._method
+
+    @property
+    def reason(self) -> str:
+        return self._reason
+
+    def __str__(self) -> str:
+        return f"Error Propagating from {self._method}: {self._reason}"

{rustplus-6.0.2 → rustplus-6.0.3}/rustplus/utils/utils.py

@@ -13,6 +13,13 @@ PLAYER_MARKER_ONLINE_COLOR = (201, 242, 155, 255)
 PLAYER_MARKER_OFFLINE_COLOR = (128, 128, 128, 255)
 
 
+def error_present(app_message) -> bool:
+    """
+    Checks message for error
+    """
+    return app_message.response.error.error != ""
+
+
 def convert_time(time) -> str:
     hours, minutes = divmod(time * 60, 60)
 

{rustplus-6.0.2 → rustplus-6.0.3/rustplus.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rustplus
-Version: 6.0.2
+Version: 6.0.3
 Summary: A python wrapper for the Rust Plus API
 Home-page: https://github.com/olijeffers0n/rustplus
 Author: olijeffers0n

{rustplus-6.0.2 → rustplus-6.0.3}/rustplus.egg-info/SOURCES.txt

@@ -93,6 +93,7 @@ rustplus/structs/__init__.py
 rustplus/structs/rust_chat_message.py
 rustplus/structs/rust_contents.py
 rustplus/structs/rust_entity_info.py
+rustplus/structs/rust_error.py
 rustplus/structs/rust_info.py
 rustplus/structs/rust_item.py
 rustplus/structs/rust_map.py