rework addresses

rustplus/annotations/chat_event.py

@@ -5,7 +5,7 @@
 from ..events import ChatEventPayload as ChatEventManager
 
 
-def ChatEvent(server_id: ServerDetails) -> Callable:
+def ChatEvent(server_details: ServerDetails) -> Callable:
 
     def wrapper(func) -> RegisteredListener:
 
@@ -14,7 +14,7 @@ def wrapper(func) -> RegisteredListener:
 
         listener = RegisteredListener(func.__name__, func)
 
-        ChatEventManager.HANDLER_LIST.register(listener, server_id)
+        ChatEventManager.HANDLER_LIST.register(listener, server_details)
 
         return listener
 

rustplus/annotations/command.py

@@ -5,7 +5,7 @@
 
 
 def Command(
-    server_id: ServerDetails, aliases: list = None, alias_func: Callable = None
+    server_details: ServerDetails, aliases: list = None, alias_func: Callable = None
 ) -> Callable:
 
     def wrapper(func):
@@ -16,7 +16,7 @@ def wrapper(func):
         command_data = ChatCommandData(
             coroutine=func, aliases=aliases, callable_func=alias_func
         )
-        ChatCommand.REGISTERED_COMMANDS[server_id][func.__name__] = command_data
+        ChatCommand.REGISTERED_COMMANDS[server_details][func.__name__] = command_data
 
         return RegisteredListener(func.__name__, func)
 

rustplus/annotations/entity_event.py

@@ -5,7 +5,7 @@
 from ..events import EntityEventPayload as EntityEventManager
 
 
-def EntityEvent(server_id: ServerDetails, eid: int) -> Callable:
+def EntityEvent(server_details: ServerDetails, eid: int) -> Callable:
     def wrapper(func) -> RegisteredListener:
         if isinstance(func, RegisteredListener):
             func = func.get_coro()
@@ -14,7 +14,7 @@ def wrapper(func) -> RegisteredListener:
             str(eid), func, 1
         )  # TODO, how are we going to handle the entity type?
 
-        EntityEventManager.HANDLER_LIST.register(listener, server_id)
+        EntityEventManager.HANDLER_LIST.register(listener, server_details)
 
         return listener
 

rustplus/annotations/protobuf_event.py

@@ -5,14 +5,14 @@
 from ..events import ProtobufEventPayload as ProtobufEventManager
 
 
-def ProtobufEvent(server_id: ServerDetails) -> Callable:
+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_id)
+        ProtobufEventManager.HANDLER_LIST.register(listener, server_details)
 
         return listener
 

rustplus/annotations/team_event.py

@@ -5,14 +5,14 @@
 from ..events import TeamEventPayload as TeamEventManager
 
 
-def TeamEvent(server_id: ServerDetails) -> Callable:
+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_id)
+        TeamEventManager.HANDLER_LIST.register(listener, server_details)
 
         return listener
 

rustplus/commands/chat_command.py

@@ -14,7 +14,9 @@ class ChatCommandTime:
 
 class ChatCommand:
 
-    REGISTERED_COMMANDS: Dict[ServerDetails, 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 ServerDetails
+from .server_details import ServerDetails

rustplus/identification/server_id.py → rustplus/identification/server_details.py

@@ -1,16 +1,29 @@
+from typing import Union
+
+
 class ServerDetails:
-    def __init__(self, ip: str, port: str, player_id: int, player_token: int) -> None:
+    def __init__(
+        self,
+        ip: str,
+        port: Union[str, int, None],
+        player_id: int,
+        player_token: int,
+        secure: bool = False,
+    ) -> None:
         self.ip = ip
         self.port = port
         self.player_id = player_id
         self.player_token = player_token
-
-    def __str__(self) -> str:
-        return f"{self.ip}:{self.port} {self.player_id} {self.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__())
 

rustplus/remote/handler_list.py

@@ -7,56 +7,69 @@ class HandlerList:
     def __init__(self) -> None:
         self._handlers: Dict[ServerDetails, Set[RegisteredListener]] = defaultdict(set)
 
-    def unregister(self, listener: RegisteredListener, server_id: ServerDetails) -> None:
-        self._handlers[server_id].remove(listener)
+    def unregister(
+        self, listener: RegisteredListener, server_details: ServerDetails
+    ) -> None:
+        self._handlers[server_details].remove(listener)
 
-    def register(self, listener: RegisteredListener, server_id: ServerDetails) -> None:
-        self._handlers[server_id].add(listener)
+    def register(
+        self, listener: RegisteredListener, server_details: ServerDetails
+    ) -> None:
+        self._handlers[server_details].add(listener)
 
-    def has(self, listener: RegisteredListener, server_id: ServerDetails) -> bool:
-        return listener in self._handlers[server_id]
+    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_id: ServerDetails) -> Set[RegisteredListener]:
-        return self._handlers.get(server_id, set())
+    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[RegisteredEntityListener]]] = (
-            defaultdict(dict)
-        )
+        self._handlers: Dict[
+            ServerDetails, Dict[str, Set[RegisteredEntityListener]]
+        ] = defaultdict(dict)
 
     def unregister(
-        self, listener: RegisteredEntityListener, server_id: ServerDetails
+        self, listener: RegisteredEntityListener, server_details: ServerDetails
     ) -> None:
-        if listener.listener_id in self._handlers.get(server_id):
-            self._handlers.get(server_id).get(listener.listener_id).remove(listener)
+        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: RegisteredEntityListener, server_id: ServerDetails) -> None:
-        if server_id not in self._handlers:
-            self._handlers[server_id] = defaultdict(set)
+    def register(
+        self, listener: RegisteredEntityListener, 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_id):
-            self._handlers.get(server_id)[listener.listener_id] = 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_id).get(listener.listener_id).add(listener)
+        self._handlers.get(server_details).get(listener.listener_id).add(listener)
 
-    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
+    def has(
+        self, listener: RegisteredEntityListener, 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_id).get(listener.listener_id)
+            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_id: ServerDetails
+        self, server_details: ServerDetails
     ) -> Dict[str, Set[RegisteredEntityListener]]:
-        return self._handlers.get(server_id, dict())
+        return self._handlers.get(server_details, dict())

rustplus/remote/ratelimiter/__init__.py

@@ -54,45 +54,45 @@ def __init__(self) -> None:
 
     def add_socket(
         self,
-        server_id: ServerDetails,
+        server_details: ServerDetails,
         current: float,
         maximum: float,
         refresh_rate: float,
         refresh_amount: float,
     ) -> None:
-        self.socket_buckets[server_id] = TokenBucket(
+        self.socket_buckets[server_details] = TokenBucket(
             current, maximum, refresh_rate, refresh_amount
         )
-        if server_id.get_server_string() not in self.server_buckets:
-            self.server_buckets[server_id.get_server_string()] = TokenBucket(
+        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_id: ServerDetails, amount: int = 1) -> bool:
+    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:
             can_consume = True
 
             for bucket in [
-                self.socket_buckets.get(server_id),
-                self.server_buckets.get(server_id.get_server_string()),
+                self.socket_buckets.get(server_details),
+                self.server_buckets.get(server_details.get_server_string()),
             ]:
                 bucket.refresh()
                 if not bucket.can_consume(amount):
                     can_consume = False
 
         return can_consume
 
-    async def consume(self, server_id: ServerDetails, amount: int = 1) -> None:
+    async def consume(self, server_details: 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
         """
         async with self.lock:
             for bucket in [
-                self.socket_buckets.get(server_id),
-                self.server_buckets.get(server_id.get_server_string()),
+                self.socket_buckets.get(server_details),
+                self.server_buckets.get(server_details.get_server_string()),
             ]:
                 bucket.refresh()
                 if not bucket.can_consume(amount):
@@ -101,16 +101,16 @@ async def consume(self, server_id: ServerDetails, amount: int = 1) -> None:
                 bucket.consume(amount)
 
     async def get_estimated_delay_time(
-        self, server_id: ServerDetails, target_cost: int
+        self, server_details: ServerDetails, target_cost: int
     ) -> float:
         """
         Returns how long until the amount of tokens needed will be available
         """
         async with self.lock:
             delay = 0
             for bucket in [
-                self.socket_buckets.get(server_id),
-                self.server_buckets.get(server_id.get_server_string()),
+                self.socket_buckets.get(server_details),
+                self.server_buckets.get(server_details.get_server_string()),
             ]:
                 val = (
                     math.ceil(
@@ -126,9 +126,9 @@ async def get_estimated_delay_time(
                     delay = val
         return delay
 
-    async def remove(self, server_id: ServerDetails) -> None:
+    async def remove(self, server_details: ServerDetails) -> None:
         """
         Removes the limiter
         """
         async with self.lock:
-            del self.socket_buckets[server_id]
+            del self.socket_buckets[server_details]