rustplus 6.0.11__tar.gz → 6.0.12__tar.gz

{rustplus-6.0.11/rustplus.egg-info → rustplus-6.0.12}/PKG-INFO

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

{rustplus-6.0.11 → rustplus-6.0.12}/rustplus/__init__.py

@@ -4,7 +4,14 @@ 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 .annotations import (
+    Command,
+    ChatEvent,
+    ProtobufEvent,
+    TeamEvent,
+    EntityEvent,
+    ClanEvent,
+)
 from .remote.fcm import FCMListener
 from .remote.camera import MovementControls, CameraMovementOptions
 from .commands import CommandOptions, ChatCommand
@@ -14,5 +21,5 @@ from .structs import RustError, RustMarker, Vector
 
 __name__ = "rustplus"
 __author__ = "olijeffers0n"
-__version__ = "6.0.11"
+__version__ = "6.0.12"
 __support__ = "Discord: https://discord.gg/nQqJe8qvP8"

{rustplus-6.0.11 → rustplus-6.0.12}/rustplus/annotations/__init__.py

@@ -3,3 +3,4 @@ from .entity_event import EntityEvent
 from .chat_event import ChatEvent
 from .team_event import TeamEvent
 from .protobuf_event import ProtobufEvent
+from .clan_event import ClanEvent

rustplus-6.0.12/rustplus/annotations/clan_event.py

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

{rustplus-6.0.11 → rustplus-6.0.12}/rustplus/events/__init__.py

@@ -2,3 +2,4 @@ from .chat_event import ChatEventPayload
 from .entity_event import EntityEventPayload
 from .team_event import TeamEventPayload
 from .protobuf_event import ProtobufEventPayload
+from .clan_info_event import ClanInfoEventPayload

rustplus-6.0.12/rustplus/events/chat_event.py

@@ -0,0 +1,27 @@
+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]
+    ) -> None:
+        self._message = message
+        self._is_clan = is_clan
+        self._clan_id = clan_id
+
+    @property
+    def message(self) -> RustChatMessage:
+        return self._message
+
+    @property
+    def is_clan(self) -> bool:
+        return self._is_clan
+
+    @property
+    def clan_id(self) -> Union[int, None]:
+        return self._clan_id

rustplus-6.0.12/rustplus/events/clan_info_event.py

@@ -0,0 +1,13 @@
+from rustplus.identification.handler_list import HandlerList
+from ..structs import RustClanInfo
+
+
+class ClanInfoEventPayload:
+    HANDLER_LIST = HandlerList()
+
+    def __init__(self, clan_info: RustClanInfo) -> None:
+        self._clan_info = clan_info
+
+    @property
+    def clan_info(self) -> RustClanInfo:
+        return self._clan_info

{rustplus-6.0.11 → rustplus-6.0.12}/rustplus/remote/websocket/ws.py

@@ -19,9 +19,10 @@ from ...events import (
     TeamEventPayload,
     ChatEventPayload,
 )
+from ...events.clan_info_event import ClanInfoEventPayload
 from ...exceptions import RequestError
 from ...identification import ServerDetails, RegisteredListener
-from ...structs import RustChatMessage, RustTeamInfo
+from ...structs import RustChatMessage, RustTeamInfo, RustClanInfo
 from ...utils import YieldingEvent, convert_time
 from ...utils.utils import error_present
 
@@ -274,14 +275,40 @@ class RustWebsocket:
             for handler in handlers:
                 await handler.get_coro()(team_event)
 
-        elif self.is_message(app_message):
+        elif self.is_clan_broadcast(app_message):
+            # Clan Event
+            if self.debug:
+                self.logger.info(f"Running Clan Event: {app_message}")
+
+            # This means that the clan of the current player has changed
+            handlers = ClanInfoEventPayload.HANDLER_LIST.get_handlers(
+                self.server_details
+            )
+            clan_event = ClanInfoEventPayload(
+                RustClanInfo(app_message.broadcast.clan_changed.clan_info)
+            )
+            for handler in handlers:
+                await handler.get_coro()(clan_event)
+
+        elif self.is_message(app_message) or self.is_clan_message(app_message):
             # Chat message event
+
+            is_clan = self.is_clan_message(app_message)
+
             if self.debug:
-                self.logger.info(f"Running Chat Event: {app_message}")
+                self.logger.info(
+                    f"Running Chat Event: {app_message}, is_clan={is_clan}"
+                )
 
             handlers = ChatEventPayload.HANDLER_LIST.get_handlers(self.server_details)
             chat_event = ChatEventPayload(
-                RustChatMessage(app_message.broadcast.team_message.message)
+                RustChatMessage(
+                    app_message.broadcast.clan_message.message
+                    if is_clan
+                    else app_message.broadcast.team_message.message
+                ),
+                is_clan,
+                app_message.broadcast.clan_message.clan_id if is_clan else None,
             )
             for handler in handlers:
                 await handler.get_coro()(chat_event)
@@ -321,6 +348,12 @@ class RustWebsocket:
             app_message.broadcast.team_message.message
         )
 
+    @staticmethod
+    def is_clan_message(app_message: AppMessage) -> bool:
+        return betterproto.serialized_on_wire(
+            app_message.broadcast.clan_message.message
+        )
+
     @staticmethod
     def is_camera_broadcast(app_message: AppMessage) -> bool:
         return betterproto.serialized_on_wire(app_message.broadcast.camera_rays)
@@ -334,27 +367,8 @@ class RustWebsocket:
         return betterproto.serialized_on_wire(app_message.broadcast.team_changed)
 
     @staticmethod
-    def get_proto_cost(app_request: AppRequest) -> int:
-        """
-        Gets the cost of an AppRequest
-        """
-        costs = [
-            (app_request.get_time, 1),
-            (app_request.send_team_message, 2),
-            (app_request.get_info, 1),
-            (app_request.get_team_chat, 1),
-            (app_request.get_team_info, 1),
-            (app_request.get_map_markers, 1),
-            (app_request.get_map, 5),
-            (app_request.set_entity_value, 1),
-            (app_request.get_entity_info, 1),
-            (app_request.promote_to_leader, 1),
-        ]
-        for request, cost in costs:
-            if betterproto.serialized_on_wire(request):
-                return cost
-
-        raise ValueError()
+    def is_clan_broadcast(app_message: AppMessage) -> bool:
+        return betterproto.serialized_on_wire(app_message.broadcast.clan_changed)
 
     @staticmethod
     async def run_coroutine_non_blocking(coroutine: Coroutine) -> Task:

{rustplus-6.0.11 → rustplus-6.0.12}/rustplus/rust_api.py

@@ -31,6 +31,8 @@ from .structs import (
     RustEntityInfo,
     RustContents,
     RustItem,
+    RustClanInfo,
+    RustClanMessage,
 )
 from .structs.rust_error import RustError
 from .utils import (
@@ -61,13 +63,16 @@ class RustSocket:
         self.command_options = command_options
         self.logger = logging.getLogger("rustplus.py")
 
-        console_handler = logging.StreamHandler()
-        console_handler.setLevel(logging.DEBUG)
-        console_handler.setFormatter(
-            logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-        )
-        self.logger.addHandler(console_handler)
-        self.logger.setLevel(logging.DEBUG)
+        if not self.logger.handlers:
+            console_handler = logging.StreamHandler()
+            console_handler.setLevel(logging.DEBUG)
+            console_handler.setFormatter(
+                logging.Formatter(
+                    "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+                )
+            )
+            self.logger.addHandler(console_handler)
+            self.logger.setLevel(logging.DEBUG)
 
         self.ws = RustWebsocket(
             self.server_details,
@@ -337,7 +342,7 @@ class RustSocket:
 
             for marker in map_markers:
                 if add_events:
-                    if marker.type in [2, 4, 5, 6, 8]:
+                    if marker.type in RustMarker.Events:
                         icon = convert_marker(int(marker.type), marker.rotation)
                         if marker.type == 6:
                             x, y = marker.x, marker.y
@@ -563,3 +568,69 @@ class RustSocket:
             return RustError("get_camera_manager", response.response.error.error)
 
         return CameraManager(self, cam_id, response.response.camera_subscribe_info)
+
+    async def get_clan_info(self) -> Union[RustClanInfo, RustError]:
+        """
+        Gets the clan information for the player's current clan.
+
+        :return RustClanInfo: The clan information
+        """
+        packet = await self._generate_request(tokens=1)
+        packet.get_clan_info = AppEmpty()
+        response = await self.ws.send_and_get(packet)
+
+        if response is None:
+            return RustError("get_clan_info", "No response received")
+
+        if error_present(response):
+            return RustError("get_clan_info", response.response.error.error)
+
+        return RustClanInfo(response.response.clan_info.clan_info)
+
+    async def get_clan_chat(self) -> Union[List[RustClanMessage], RustError]:
+        """
+        Gets the clan chat for the player's current clan.
+
+        :return List[RustClanMessage]: The clan chat
+        """
+        packet = await self._generate_request(tokens=1)
+        packet.get_clan_chat = AppEmpty()
+        response = await self.ws.send_and_get(packet)
+
+        if response is None:
+            return RustError("get_clan_chat", "No response received")
+
+        if error_present(response):
+            return RustError("get_clan_chat", response.response.error.error)
+
+        return [
+            RustClanMessage(message) for message in response.response.clan_chat.messages
+        ]
+
+    async def send_clan_message(self, message: str) -> None:
+        """
+        Sends a message to the in-game clan chat
+
+        :param message: The string message to send
+        """
+
+        packet = await self._generate_request(tokens=2)
+        send_message = AppSendMessage()
+        send_message.message = message
+        packet.send_clan_message = send_message
+
+        await self.ws.send_message(packet, True)
+
+    async def set_clan_motd(self, message: str) -> None:
+        """
+        Sets the clan's message of the day
+
+        :param message: The string message to set as the clan's message of the day
+        """
+
+        packet = await self._generate_request()
+        send_message = AppSendMessage()
+        send_message.message = message
+        packet.set_clan_motd = send_message
+
+        await self.ws.send_message(packet, True)

{rustplus-6.0.11 → rustplus-6.0.12}/rustplus/structs/__init__.py

@@ -9,3 +9,4 @@ from .rust_contents import RustContents
 from .rust_item import RustItem
 from .util import Vector
 from .rust_error import RustError
+from .clans import *

rustplus-6.0.12/rustplus/structs/clans/__init__.py

@@ -0,0 +1,2 @@
+from .rust_clan_message import RustClanMessage
+from .rust_clan_info import RustClanInfo

rustplus-6.0.12/rustplus/structs/clans/rust_clan_info.py

@@ -0,0 +1,247 @@
+from ...remote.rustplus_proto import (
+    ClanInfo,
+    ClanInfoRole,
+    ClanInfoMember,
+    ClanInfoInvite,
+)
+from typing import List
+
+
+class RustClanRole:
+    def __init__(self, role: ClanInfoRole) -> None:
+        self._role_id: int = role.role_id
+        self._rank: int = role.rank
+        self._name: str = role.name
+        self._can_set_motd: bool = role.can_set_motd
+        self._can_set_logo: bool = role.can_set_logo
+        self._can_invite: bool = role.can_invite
+        self._can_kick: bool = role.can_kick
+        self._can_promote: bool = role.can_promote
+        self._can_demote: bool = role.can_demote
+        self._can_set_player_notes: bool = role.can_set_player_notes
+        self._can_access_logs: bool = role.can_access_logs
+
+    @property
+    def role_id(self) -> int:
+        return self._role_id
+
+    @property
+    def rank(self) -> int:
+        return self._rank
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def can_set_motd(self) -> bool:
+        return self._can_set_motd
+
+    @property
+    def can_set_logo(self) -> bool:
+        return self._can_set_logo
+
+    @property
+    def can_invite(self) -> bool:
+        return self._can_invite
+
+    @property
+    def can_kick(self) -> bool:
+        return self._can_kick
+
+    @property
+    def can_promote(self) -> bool:
+        return self._can_promote
+
+    @property
+    def can_demote(self) -> bool:
+        return self._can_demote
+
+    @property
+    def can_set_player_notes(self) -> bool:
+        return self._can_set_player_notes
+
+    @property
+    def can_access_logs(self) -> bool:
+        return self._can_access_logs
+
+    def __str__(self):
+        return (
+            "RustClanRole[role_id={}, rank={}, name={}, can_set_motd={}, can_set_logo={}, can_invite={}, "
+            "can_kick={}, can_promote={}, can_demote={}, can_set_player_notes={}, can_access_logs={}]"
+        ).format(
+            self._role_id,
+            self._rank,
+            self._name,
+            self._can_set_motd,
+            self._can_set_logo,
+            self._can_invite,
+            self._can_kick,
+            self._can_promote,
+            self._can_demote,
+            self._can_set_player_notes,
+            self._can_access_logs,
+        )
+
+
+class RustClanMember:
+    def __init__(self, member: ClanInfoMember) -> None:
+        self._steam_id: int = member.steam_id
+        self._role_id: int = member.role_id
+        self._joined_time: int = member.joined
+        self._last_seen: int = member.last_seen
+        self._notes: str = member.notes
+        self._online: bool = member.online
+
+    @property
+    def steam_id(self) -> int:
+        return self._steam_id
+
+    @property
+    def role_id(self) -> int:
+        return self._role_id
+
+    @property
+    def joined_time(self) -> int:
+        return self._joined_time
+
+    @property
+    def last_seen(self) -> int:
+        return self._last_seen
+
+    @property
+    def notes(self) -> str:
+        return self._notes
+
+    @property
+    def online(self) -> bool:
+        return self._online
+
+    def __str__(self):
+        return "RustClanMember[steam_id={}, role_id={}, joined_time={}, last_seen={}, notes={}, online={}]".format(
+            self._steam_id,
+            self._role_id,
+            self._joined_time,
+            self._last_seen,
+            self._notes,
+            self._online,
+        )
+
+
+class RustClanInvite:
+    def __init__(self, invite: ClanInfoInvite) -> None:
+        self._steam_id: int = invite.steam_id
+        self._recruiter: int = invite.recruiter
+        self._invited_time: int = invite.timestamp
+
+    @property
+    def steam_id(self) -> int:
+        return self._steam_id
+
+    @property
+    def recruiter(self) -> int:
+        return self._recruiter
+
+    @property
+    def invited_time(self) -> int:
+        return self._invited_time
+
+    def __str__(self):
+        return "RustClanInvite[steam_id={}, recruiter={}, invited_time={}]".format(
+            self._steam_id, self._recruiter, self._invited_time
+        )
+
+
+class RustClanInfo:
+    def __init__(self, clan_info: ClanInfo) -> None:
+        self._clan_id: int = clan_info.clan_id
+        self._clan_name: str = clan_info.name
+        self._clan_time_created: int = clan_info.created
+        self._creator: int = clan_info.creator
+        self._motd: str = clan_info.motd
+        self._motd_time_set: int = clan_info.motd_timestamp
+        self._motd_author: int = clan_info.motd_author
+        self._logo: bytes = clan_info.logo
+        self._colour: int = clan_info.color
+        self._roles: List[RustClanRole] = [
+            RustClanRole(role) for role in clan_info.roles
+        ]
+        self._members: List[RustClanMember] = [
+            RustClanMember(member) for member in clan_info.members
+        ]
+        self._invites: List[RustClanInvite] = [
+            RustClanInvite(invite) for invite in clan_info.invites
+        ]
+        self._max_members: int = clan_info.max_member_count
+
+    @property
+    def clan_id(self) -> int:
+        return self._clan_id
+
+    @property
+    def clan_name(self) -> str:
+        return self._clan_name
+
+    @property
+    def clan_time_created(self) -> int:
+        return self._clan_time_created
+
+    @property
+    def creator(self) -> int:
+        return self._creator
+
+    @property
+    def motd(self) -> str:
+        return self._motd
+
+    @property
+    def motd_time_set(self) -> int:
+        return self._motd_time_set
+
+    @property
+    def motd_author(self) -> int:
+        return self._motd_author
+
+    @property
+    def logo(self) -> bytes:
+        return self._logo
+
+    @property
+    def colour(self) -> int:
+        return self._colour
+
+    @property
+    def roles(self) -> List[RustClanRole]:
+        return self._roles
+
+    @property
+    def members(self) -> List[RustClanMember]:
+        return self._members
+
+    @property
+    def invites(self) -> List[RustClanInvite]:
+        return self._invites
+
+    @property
+    def max_members(self) -> int:
+        return self._max_members
+
+    def __str__(self):
+        return (
+            "RustClanInfo[clan_id={}, clan_name={}, clan_time_created={}, creator={}, motd={}, motd_time_set={}, "
+            "motd_author={}, logo={}, colour={}, roles={}, members={}, invites={}, max_members={}]"
+        ).format(
+            self._clan_id,
+            self._clan_name,
+            self._clan_time_created,
+            self._creator,
+            self._motd,
+            self._motd_time_set,
+            self._motd_author,
+            self._logo,
+            self._colour,
+            self._roles,
+            self._members,
+            self._invites,
+            self._max_members,
+        )

rustplus-6.0.12/rustplus/structs/clans/rust_clan_message.py

@@ -0,0 +1,30 @@
+from ...remote.rustplus_proto import AppClanMessage
+
+
+class RustClanMessage:
+    def __init__(self, message: AppClanMessage) -> None:
+        self._steam_id: int = message.steam_id
+        self._name: str = message.name
+        self._message: str = message.message
+        self._timestamp: int = message.time
+
+    @property
+    def steam_id(self) -> int:
+        return self._steam_id
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def message(self) -> str:
+        return self._message
+
+    @property
+    def timestamp(self) -> int:
+        return self._timestamp
+
+    def __str__(self):
+        return "RustClanMessage[steam_id={}, name={}, message={}, timestamp={}]".format(
+            self._steam_id, self._name, self._message, self._timestamp
+        )

{rustplus-6.0.11 → rustplus-6.0.12}/rustplus/structs/rust_chat_message.py

@@ -1,15 +1,20 @@
-from ..remote.rustplus_proto import AppTeamMessage
+from typing import Union
+from ..remote.rustplus_proto import AppTeamMessage, AppClanMessage
 from .serialization import Serializable
 
 
 class RustChatMessage(Serializable):
-    def __init__(self, data: AppTeamMessage):
+    def __init__(self, data: Union[AppTeamMessage, AppClanMessage]):
         self._steam_id: int = data.steam_id
         self._name: str = data.name
         self._message: str = data.message
-        self._colour: str = data.color
         self._time: int = data.time
 
+        if isinstance(data, AppTeamMessage):
+            self._colour: str = data.color
+        else:
+            self._colour: str = "#af5"
+
     @property
     def steam_id(self) -> int:
         return self._steam_id

{rustplus-6.0.11 → rustplus-6.0.12}/rustplus/structs/rust_info.py

@@ -15,6 +15,9 @@ class RustInfo(Serializable):
         self._queued_players: int = data.queued_players
         self._seed: int = data.seed
         self._logo_image: str = data.logo_image
+        self._nexus: str = data.nexus
+        self._nexus_id: int = data.nexus_id
+        self._nexus_zone: str = data.nexus_zone
 
     @property
     def url(self) -> str:
@@ -60,10 +63,22 @@ class RustInfo(Serializable):
     def logo_image(self) -> str:
         return self._logo_image
 
+    @property
+    def nexus(self) -> str:
+        return self._nexus
+
+    @property
+    def nexus_id(self) -> int:
+        return self._nexus_id
+
+    @property
+    def nexus_zone(self) -> str:
+        return self._nexus_zone
+
     def __str__(self) -> str:
         return (
             "RustInfo[url={}, name={}, map={}, size={}, players={}, max_players={}, queued_players={}, seed={}, "
-            "wipe_time={}, header_image={}, logo_image={}]".format(
+            "wipe_time={}, header_image={}, logo_image={}, nexus={}, nexus_id={}, nexus_zone={}]".format(
                 self._url,
                 self._name,
                 self._map,
@@ -75,5 +90,8 @@ class RustInfo(Serializable):
                 self._wipe_time,
                 self._header_image,
                 self._logo_image,
+                self._nexus,
+                self._nexus_id,
+                self._nexus_zone,
             )
         )

{rustplus-6.0.11 → rustplus-6.0.12}/rustplus/structs/rust_marker.py

@@ -95,6 +95,15 @@ class RustMarker(Serializable):
     PatrolHelicopterMarker = 8
     TravelingVendor = 9
 
+    Events = (
+        ExplosionMarker,
+        ChinookMarker,
+        CargoShipMarker,
+        CrateMarker,
+        PatrolHelicopterMarker,
+        TravelingVendor,
+    )
+
     def __init__(self, data: AppMarker) -> None:
         self._id: int = data.id
         self._type: int = data.type

{rustplus-6.0.11 → rustplus-6.0.12/rustplus.egg-info}/PKG-INFO

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

{rustplus-6.0.11 → rustplus-6.0.12}/rustplus.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ rustplus.egg-info/requires.txt
 rustplus.egg-info/top_level.txt
 rustplus/annotations/__init__.py
 rustplus/annotations/chat_event.py
+rustplus/annotations/clan_event.py
 rustplus/annotations/command.py
 rustplus/annotations/entity_event.py
 rustplus/annotations/protobuf_event.py
@@ -23,6 +24,7 @@ rustplus/commands/chat_command_data.py
 rustplus/commands/command_options.py
 rustplus/events/__init__.py
 rustplus/events/chat_event.py
+rustplus/events/clan_info_event.py
 rustplus/events/entity_event.py
 rustplus/events/protobuf_event.py
 rustplus/events/team_event.py
@@ -104,6 +106,9 @@ rustplus/structs/rust_team_info.py
 rustplus/structs/rust_time.py
 rustplus/structs/serialization.py
 rustplus/structs/util.py
+rustplus/structs/clans/__init__.py
+rustplus/structs/clans/rust_clan_info.py
+rustplus/structs/clans/rust_clan_message.py
 rustplus/utils/__init__.py
 rustplus/utils/deprecated.py
 rustplus/utils/emojis.py

rustplus-6.0.11/rustplus/events/chat_event.py

@@ -1,13 +0,0 @@
-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