rustplus 6.0.10__tar.gz → 6.0.12__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rustplus
-Version: 6.0.10
+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.10 → 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.10"
+__version__ = "6.0.12"
 __support__ = "Discord: https://discord.gg/nQqJe8qvP8"

{rustplus-6.0.10 → 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.10 → 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.10 → rustplus-6.0.12}/rustplus/remote/ratelimiter/__init__.py

@@ -1,6 +1,6 @@
 import math
 import time
-import asyncio
+import threading
 from typing import Dict
 
 from ...exceptions.exceptions import RateLimitError
@@ -34,6 +34,8 @@ class TokenBucket:
 
 
 class RateLimiter:
+    SOCKET_LIMIT = 25
+    SOCKET_REFRESH_AMOUNT = 3
     SERVER_LIMIT = 50
     SERVER_REFRESH_AMOUNT = 15
 
@@ -47,7 +49,7 @@ class RateLimiter:
     def __init__(self) -> None:
         self.socket_buckets: Dict[ServerDetails, TokenBucket] = {}
         self.server_buckets: Dict[str, TokenBucket] = {}
-        self.lock = asyncio.Lock()
+        self.lock = threading.Lock()
 
     def add_socket(
         self,
@@ -57,19 +59,21 @@ class RateLimiter:
         refresh_rate: float,
         refresh_amount: float,
     ) -> None:
-        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(
-                self.SERVER_LIMIT, self.SERVER_LIMIT, 1, self.SERVER_REFRESH_AMOUNT
-            )
+        with self.lock:
+            if server_details not in self.socket_buckets:
+                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(
+                    self.SERVER_LIMIT, self.SERVER_LIMIT, 1, self.SERVER_REFRESH_AMOUNT
+                )
 
     async def can_consume(self, server_details: ServerDetails, amount: int = 1) -> bool:
         """
         Returns whether the user can consume the amount of tokens provided
         """
-        async with self.lock:
+        with self.lock:
             for bucket in [
                 self.socket_buckets.get(server_details),
                 self.server_buckets.get(server_details.get_server_string()),
@@ -83,7 +87,7 @@ class RateLimiter:
         """
         Consumes an amount of tokens from the bucket. You should first check to see whether it is possible with can_consume
         """
-        async with self.lock:
+        with self.lock:
             for bucket in [
                 self.socket_buckets.get(server_details),
                 self.server_buckets.get(server_details.get_server_string()),
@@ -103,12 +107,14 @@ class RateLimiter:
         """
         Returns how long until the amount of tokens needed will be available
         """
-        async with self.lock:
+
+        with self.lock:
             delay = 0
             for bucket in [
                 self.socket_buckets.get(server_details),
                 self.server_buckets.get(server_details.get_server_string()),
             ]:
+                bucket.refresh()
                 val = (
                     math.ceil(
                         (
@@ -127,5 +133,10 @@ class RateLimiter:
         """
         Removes the limiter
         """
-        async with self.lock:
+        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
+            ):
+                del self.server_buckets[server_str]

{rustplus-6.0.10 → 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.10 → 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,
@@ -85,10 +90,10 @@ class RustSocket:
 
         self.ratelimiter.add_socket(
             self.server_details,
-            RateLimiter.SERVER_LIMIT,
-            RateLimiter.SERVER_LIMIT,
+            RateLimiter.SOCKET_LIMIT,
+            RateLimiter.SOCKET_LIMIT,
             1,
-            RateLimiter.SERVER_REFRESH_AMOUNT,
+            RateLimiter.SOCKET_REFRESH_AMOUNT,
         )
 
     async def _handle_ratelimit(self, tokens) -> None:
@@ -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.10 → 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,
+        )