Trialling ServerID -> ServerDetails

rustplus/__init__.py

@@ -3,7 +3,7 @@
 """
 
 from .rust_api import RustSocket
-from .identification import ServerID
+from .identification import ServerDetails
 from .annotations import Command, ChatEvent, ProtobufEvent, TeamEvent, EntityEvent
 from .commands import CommandOptions
 from .events import ChatEventPayload, TeamEventPayload, EntityEventPayload

rustplus/annotations/chat_event.py

@@ -1,11 +1,11 @@
 from typing import Callable
 
-from .. import ServerID
+from .. import ServerDetails
 from ..identification import RegisteredListener
 from ..events import ChatEventPayload as ChatEventManager
 
 
-def ChatEvent(server_id: ServerID) -> Callable:
+def ChatEvent(server_id: ServerDetails) -> Callable:
 
     def wrapper(func) -> RegisteredListener:
 

rustplus/annotations/command.py

@@ -1,11 +1,11 @@
 from typing import Callable
 
-from ..identification import RegisteredListener, ServerID
+from ..identification import RegisteredListener, ServerDetails
 from ..commands import ChatCommand, ChatCommandData
 
 
 def Command(
-    server_id: ServerID, aliases: list = None, alias_func: Callable = None
+    server_id: ServerDetails, aliases: list = None, alias_func: Callable = None
 ) -> Callable:
 
     def wrapper(func):

rustplus/annotations/entity_event.py

@@ -1,11 +1,11 @@
 from typing import Callable
 
-from .. import ServerID
+from .. import ServerDetails
 from ..identification import RegisteredEntityListener, RegisteredListener
 from ..events import EntityEventPayload as EntityEventManager
 
 
-def EntityEvent(server_id: ServerID, eid: int) -> Callable:
+def EntityEvent(server_id: ServerDetails, eid: int) -> Callable:
     def wrapper(func) -> RegisteredListener:
         if isinstance(func, RegisteredListener):
             func = func.get_coro()

rustplus/annotations/protobuf_event.py

@@ -1,11 +1,11 @@
 from typing import Callable
 
-from .. import ServerID
+from .. import ServerDetails
 from ..identification import RegisteredListener
 from ..events import ProtobufEventPayload as ProtobufEventManager
 
 
-def ProtobufEvent(server_id: ServerID) -> Callable:
+def ProtobufEvent(server_id: ServerDetails) -> Callable:
     def wrapper(func) -> RegisteredListener:
         if isinstance(func, RegisteredListener):
             func = func.get_coro()

rustplus/annotations/team_event.py

@@ -1,11 +1,11 @@
 from typing import Callable
 
-from .. import ServerID
+from .. import ServerDetails
 from ..identification import RegisteredListener
 from ..events import TeamEventPayload as TeamEventManager
 
 
-def TeamEvent(server_id: ServerID) -> Callable:
+def TeamEvent(server_id: ServerDetails) -> Callable:
     def wrapper(func) -> RegisteredListener:
         if isinstance(func, RegisteredListener):
             func = func.get_coro()

rustplus/commands/chat_command.py

@@ -3,7 +3,7 @@
 from typing import Dict, List
 
 from .chat_command_data import ChatCommandData
-from ..identification import ServerID
+from ..identification import ServerDetails
 
 
 @dataclasses.dataclass
@@ -14,7 +14,7 @@ class ChatCommandTime:
 
 class ChatCommand:
 
-    REGISTERED_COMMANDS: Dict[ServerID, Dict[str, ChatCommandData]] = defaultdict(dict)
+    REGISTERED_COMMANDS: Dict[ServerDetails, Dict[str, ChatCommandData]] = defaultdict(dict)
 
     def __init__(
         self,

rustplus/identification/__init__.py

@@ -1,2 +1,2 @@
 from .registered_listener import RegisteredListener, RegisteredEntityListener
-from .server_id import ServerID
+from .server_id import ServerDetails

rustplus/identification/server_id.py

@@ -1,4 +1,4 @@
-class ServerID:
+class ServerDetails:
     def __init__(self, ip: str, port: str, player_id: int, player_token: int) -> None:
         self.ip = ip
         self.port = port
@@ -15,7 +15,7 @@ def __hash__(self):
         return hash(self.__str__())
 
     def __eq__(self, o: object) -> bool:
-        if not isinstance(o, ServerID):
+        if not isinstance(o, ServerDetails):
             return False
 
         return (

rustplus/remote/handler_list.py

@@ -1,42 +1,42 @@
 from collections import defaultdict
 from typing import Set, Dict
-from ..identification import RegisteredListener, RegisteredEntityListener, ServerID
+from ..identification import RegisteredListener, RegisteredEntityListener, ServerDetails
 
 
 class HandlerList:
     def __init__(self) -> None:
-        self._handlers: Dict[ServerID, Set[RegisteredListener]] = defaultdict(set)
+        self._handlers: Dict[ServerDetails, Set[RegisteredListener]] = defaultdict(set)
 
-    def unregister(self, listener: RegisteredListener, server_id: ServerID) -> None:
+    def unregister(self, listener: RegisteredListener, server_id: ServerDetails) -> None:
         self._handlers[server_id].remove(listener)
 
-    def register(self, listener: RegisteredListener, server_id: ServerID) -> None:
+    def register(self, listener: RegisteredListener, server_id: ServerDetails) -> None:
         self._handlers[server_id].add(listener)
 
-    def has(self, listener: RegisteredListener, server_id: ServerID) -> bool:
+    def has(self, listener: RegisteredListener, server_id: ServerDetails) -> bool:
         return listener in self._handlers[server_id]
 
     def unregister_all(self) -> None:
         self._handlers.clear()
 
-    def get_handlers(self, server_id: ServerID) -> Set[RegisteredListener]:
+    def get_handlers(self, server_id: ServerDetails) -> Set[RegisteredListener]:
         return self._handlers.get(server_id, set())
 
 
 class EntityHandlerList(HandlerList):
     def __init__(self) -> None:
         super().__init__()
-        self._handlers: Dict[ServerID, Dict[str, Set[RegisteredEntityListener]]] = (
+        self._handlers: Dict[ServerDetails, Dict[str, Set[RegisteredEntityListener]]] = (
             defaultdict(dict)
         )
 
     def unregister(
-        self, listener: RegisteredEntityListener, server_id: ServerID
+        self, listener: RegisteredEntityListener, server_id: ServerDetails
     ) -> None:
         if listener.listener_id in self._handlers.get(server_id):
             self._handlers.get(server_id).get(listener.listener_id).remove(listener)
 
-    def register(self, listener: RegisteredEntityListener, server_id: ServerID) -> None:
+    def register(self, listener: RegisteredEntityListener, server_id: ServerDetails) -> None:
         if server_id not in self._handlers:
             self._handlers[server_id] = defaultdict(set)
 
@@ -45,7 +45,7 @@ def register(self, listener: RegisteredEntityListener, server_id: ServerID) -> N
 
         self._handlers.get(server_id).get(listener.listener_id).add(listener)
 
-    def has(self, listener: RegisteredEntityListener, server_id: ServerID) -> bool:
+    def has(self, listener: RegisteredEntityListener, server_id: ServerDetails) -> bool:
         if server_id in self._handlers and listener.listener_id in self._handlers.get(
             server_id
         ):
@@ -57,6 +57,6 @@ def unregister_all(self) -> None:
         self._handlers.clear()
 
     def get_handlers(
-        self, server_id: ServerID
+        self, server_id: ServerDetails
     ) -> Dict[str, Set[RegisteredEntityListener]]:
         return self._handlers.get(server_id, dict())

rustplus/remote/ratelimiter/__init__.py

@@ -4,7 +4,7 @@
 from typing import Dict
 
 from ...exceptions.exceptions import RateLimitError
-from ...identification import ServerID
+from ...identification import ServerDetails
 
 
 class TokenBucket:
@@ -48,13 +48,13 @@ def default(cls) -> "RateLimiter":
         return cls()
 
     def __init__(self) -> None:
-        self.socket_buckets: Dict[ServerID, TokenBucket] = {}
+        self.socket_buckets: Dict[ServerDetails, TokenBucket] = {}
         self.server_buckets: Dict[str, TokenBucket] = {}
         self.lock = asyncio.Lock()
 
     def add_socket(
         self,
-        server_id: ServerID,
+        server_id: ServerDetails,
         current: float,
         maximum: float,
         refresh_rate: float,
@@ -68,7 +68,7 @@ def add_socket(
                 self.SERVER_LIMIT, self.SERVER_LIMIT, 1, self.SERVER_REFRESH_AMOUNT
             )
 
-    async def can_consume(self, server_id: ServerID, amount: int = 1) -> bool:
+    async def can_consume(self, server_id: ServerDetails, amount: int = 1) -> bool:
         """
         Returns whether the user can consume the amount of tokens provided
         """
@@ -85,7 +85,7 @@ async def can_consume(self, server_id: ServerID, amount: int = 1) -> bool:
 
         return can_consume
 
-    async def consume(self, server_id: ServerID, amount: int = 1) -> None:
+    async def consume(self, server_id: ServerDetails, amount: int = 1) -> None:
         """
         Consumes an amount of tokens from the bucket. You should first check to see whether it is possible with can_consume
         """
@@ -101,7 +101,7 @@ async def consume(self, server_id: ServerID, amount: int = 1) -> None:
                 bucket.consume(amount)
 
     async def get_estimated_delay_time(
-        self, server_id: ServerID, target_cost: int
+        self, server_id: ServerDetails, target_cost: int
     ) -> float:
         """
         Returns how long until the amount of tokens needed will be available
@@ -126,7 +126,7 @@ async def get_estimated_delay_time(
                     delay = val
         return delay
 
-    async def remove(self, server_id: ServerID) -> None:
+    async def remove(self, server_id: ServerDetails) -> None:
         """
         Removes the limiter
         """

rustplus/remote/websocket/ws.py

@@ -18,7 +18,7 @@
     ChatEventPayload,
 )
 from ...exceptions import ClientNotConnectedError, RequestError
-from ...identification import ServerID, RegisteredListener
+from ...identification import ServerDetails, RegisteredListener
 from ...structs import RustChatMessage, RustTeamInfo
 from ...utils import YieldingEvent, convert_time
 
@@ -28,10 +28,10 @@ class RustWebsocket:
     RESPONSE_TIMEOUT = 5
 
     def __init__(
-        self, server_id: ServerID, command_options: Union[None, CommandOptions]
+        self, server_id: ServerDetails, command_options: Union[CommandOptions, None]
     ) -> None:
-        self.server_id: ServerID = server_id
-        self.command_options: Union[None, CommandOptions] = command_options
+        self.server_id: ServerDetails = server_id
+        self.command_options: Union[CommandOptions, None] = command_options
         self.connection: Union[WebSocketClientProtocol, None] = None
         self.logger: logging.Logger = logging.getLogger("rustplus.py")
         self.task: Union[Task, None] = None
@@ -237,7 +237,7 @@ def get_prefix(self, message: str) -> Optional[str]:
             return None
 
     @staticmethod
-    async def run_proto_event(data: Union[str, bytes], server_id: ServerID) -> None:
+    async def run_proto_event(data: Union[str, bytes], server_id: ServerDetails) -> None:
         handlers: Set[RegisteredListener] = (
             ProtobufEventPayload.HANDLER_LIST.get_handlers(server_id)
         )

rustplus/rust_api.py

@@ -6,7 +6,7 @@
 from PIL import Image
 
 from .commands import CommandOptions
-from .identification import ServerID
+from .identification import ServerDetails
 from .remote.camera import CameraManager
 from .remote.rustplus_proto import (
     AppRequest,
@@ -36,7 +36,7 @@ class RustSocket:
 
     def __init__(
         self,
-        server_id: ServerID,
+        server_id: ServerDetails,
         ratelimiter: Union[None, RateLimiter] = None,
         command_options: Union[None, CommandOptions] = None,
     ) -> None: