Better parameter naming

Author: BattlefieldDuck

README.md

@@ -57,7 +57,7 @@ import asyncio
 from opengsq.protocols import Source
 
 async def main():
-    source = Source(address='45.147.5.5', query_port=27015)
+    source = Source(host='45.147.5.5', port=27015)
     info = await source.get_info()
     print(info)
 
@@ -91,7 +91,7 @@ which makes it easy to query game servers from your terminal. Run
 
 ```sh
 # query server using source protocol
-opengsq source --address 123.123.123.123 --query_port 27015 --function get_info
+opengsq source --host 123.123.123.123 --port 27015 --function get_info
 ```
 
 ## Tests and Results

opengsq/protocol_base.py

@@ -7,7 +7,7 @@ class ProtocolBase(abc.ABC):
     def full_name(self):
         pass
 
-    def __init__(self, address: str, query_port: int, timeout: float = 5.0):
-        self._address = address
-        self._query_port = query_port
+    def __init__(self, host: str, port: int, timeout: float = 5.0):
+        self._host = host
+        self._port = port
         self._timeout = timeout

opengsq/protocols/ase.py

@@ -14,7 +14,7 @@ class ASE(ProtocolBase):
     async def get_status(self) -> dict:
         with SocketAsync() as sock:
             sock.settimeout(self._timeout)
-            await sock.connect((self._address, self._query_port))
+            await sock.connect((self._host, self._port))
 
             # Send Request
             sock.send(self._request)
@@ -87,7 +87,7 @@ def __read_string(self, br: BinaryReader):
 
     async def main_async():
         # mtasa
-        ase = ASE(address='79.137.97.3', query_port=22126, timeout=10.0)
+        ase = ASE(host='79.137.97.3', port=22126, timeout=10.0)
         status = await ase.get_status()
         print(json.dumps(status, indent=None) + '\n')
 

opengsq/protocols/battlefield.py

@@ -73,7 +73,7 @@ async def get_players(self) -> list:
 
     async def __get_data(self, request: bytes):
         kind = SocketKind.SOCK_STREAM
-        response = await SocketAsync.send_and_receive(self._address, self._query_port, self._timeout, request, kind)
+        response = await SocketAsync.send_and_receive(self._host, self._port, self._timeout, request, kind)
         return self.__decode(response)
 
     def __decode(self, response: bytes):

opengsq/protocols/doom3.py

@@ -18,7 +18,7 @@ class Doom3(ProtocolBase):
 
     async def get_info(self, strip_color=True):
         request = b'\xFF\xFFgetInfo\x00ogsq\x00'
-        response = await SocketAsync.send_and_receive(self._address, self._query_port, self._timeout, request)
+        response = await SocketAsync.send_and_receive(self._host, self._port, self._timeout, request)
 
         # Remove the first two 0xFF
         br = BinaryReader(response[2:])
@@ -104,17 +104,17 @@ def strip_colors(text: str):
 
     async def main_async():
         # doom3
-        doom3 = Doom3(address='66.85.14.240', query_port=27666, timeout=5.0)
+        doom3 = Doom3(host='66.85.14.240', port=27666, timeout=5.0)
         info = await doom3.get_info()
         print(json.dumps(info, indent=None) + '\n')
 
         # etqw
-        doom3 = Doom3(address='178.162.135.83', query_port=27735, timeout=5.0)
+        doom3 = Doom3(host='178.162.135.83', port=27735, timeout=5.0)
         info = await doom3.get_info()
         print(json.dumps(info, indent=None) + '\n')
 
         # quake4
-        doom3 = Doom3(address='88.99.0.7', query_port=28007, timeout=5.0)
+        doom3 = Doom3(host='88.99.0.7', port=28007, timeout=5.0)
         info = await doom3.get_info()
         print(json.dumps(info, indent=None) + '\n')
 

opengsq/protocols/gamespy1.py

@@ -106,7 +106,7 @@ async def __connect_and_send(self, data) -> BinaryReader:
         # Connect to remote host
         with SocketAsync() as sock:
             sock.settimeout(self._timeout)
-            await sock.connect((self._address, self._query_port))
+            await sock.connect((self._host, self._port))
 
             sock.send(data)
             br = BinaryReader(await self.__get_packets_response(sock))
@@ -179,10 +179,10 @@ def __parse_as_object(self, br: BinaryReader, is_player=False):
     import json
 
     async def main_async():
-        gs1 = GameSpy1(address='51.81.48.224', query_port=23000, timeout=5.0)  # bfield1942
+        gs1 = GameSpy1(host='51.81.48.224', port=23000, timeout=5.0)  # bfield1942
         #gs1 = GameSpy1(address='139.162.235.20', query_port=7778, timeout=5.0)  # ut
         #gs1 = GameSpy1(address='192.223.24.6', query_port=7778, timeout=5.0)  # ut
-        gs1 = GameSpy1(address='141.94.205.35', query_port=12300, timeout=5.0)  # mohaa
+        gs1 = GameSpy1(host='141.94.205.35', port=12300, timeout=5.0)  # mohaa
         status = await gs1.get_status()
         print(json.dumps(status, indent=None) + '\n')
 

opengsq/protocols/gamespy2.py

@@ -19,7 +19,7 @@ async def get_status(self, request: Request = Request.INFO | Request.PLAYERS | R
         # Connect to remote host
         with SocketAsync() as sock:
             sock.settimeout(self._timeout)
-            await sock.connect((self._address, self._query_port))
+            await sock.connect((self._host, self._port))
 
             # Send Request
             sock.send(b'\xFE\xFD\x00\x04\x05\x06\x07' + self.__get_request_bytes(request))
@@ -125,7 +125,7 @@ def __get_teams(self, br: BinaryReader) -> list:
     import json
 
     async def main_async():
-        gs2 = GameSpy2(address='158.69.118.94', query_port=23000, timeout=5.0)
+        gs2 = GameSpy2(host='158.69.118.94', port=23000, timeout=5.0)
         status = await gs2.get_status()
         print(json.dumps(status, indent=None) + '\n')
 

opengsq/protocols/gamespy3.py

@@ -16,7 +16,7 @@ async def get_status(self):
         # Connect to remote host
         with SocketAsync() as sock:
             sock.settimeout(self._timeout)
-            await sock.connect((self._address, self._query_port))
+            await sock.connect((self._host, self._port))
 
             request_h = b'\xFE\xFD'
             timestamp = b'\x04\x05\x06\x07'
@@ -139,7 +139,7 @@ async def __read(self, sock) -> bytes:
     import json
 
     async def main_async():
-        gs3 = GameSpy3(address='185.107.96.59', query_port=29900, timeout=5.0)
+        gs3 = GameSpy3(host='185.107.96.59', port=29900, timeout=5.0)
         server = await gs3.get_status()
         print(json.dumps(server, indent=None))
 

opengsq/protocols/gamespy4.py

@@ -12,7 +12,7 @@ class GameSpy4(GameSpy3):
     import json
 
     async def main_async():
-        gs4 = GameSpy4(address='188.18.10.72', query_port=19133, timeout=5.0)
+        gs4 = GameSpy4(host='188.18.10.72', port=19133, timeout=5.0)
         server = await gs4.get_status()
         print(json.dumps(server, indent=None))
 

opengsq/protocols/minecraft.py

@@ -24,14 +24,14 @@ async def get_status(self, version=47, strip_color=True) -> dict:
         """
 
         # Prepare the request
-        address = self._address.encode('utf8')
+        address = self._host.encode('utf8')
         protocol = self._pack_varint(version)
-        request = b'\x00' + protocol + self._pack_varint(len(address)) + address + struct.pack('H', self._query_port) + b'\x01'
+        request = b'\x00' + protocol + self._pack_varint(len(address)) + address + struct.pack('H', self._port) + b'\x01'
         request = self._pack_varint(len(request)) + request + b'\x01\x00'
 
         with SocketAsync(SocketKind.SOCK_STREAM) as sock:
             sock.settimeout(self._timeout)
-            await sock.connect((self._address, self._query_port))
+            await sock.connect((self._host, self._port))
             sock.send(request)
 
             response = await sock.recv()
@@ -72,7 +72,7 @@ async def get_status_pre17(self, strip_color=True) -> dict:
         """Get ping info from a server that uses a version older than Minecraft 1.7"""
         with SocketAsync(SocketKind.SOCK_STREAM) as sock:
             sock.settimeout(self._timeout)
-            await sock.connect((self._address, self._query_port))
+            await sock.connect((self._host, self._port))
             sock.send(b'\xFE\x01')
             response = await sock.recv()
 
@@ -141,7 +141,7 @@ def _unpack_varint(self, br: BinaryReader):
     import asyncio
 
     async def main_async():
-        minecraft = Minecraft(address='51.83.219.117', query_port=25565, timeout=5.0)
+        minecraft = Minecraft(host='51.83.219.117', port=25565, timeout=5.0)
         status = await minecraft.get_status(47, strip_color=True)
         print(json.dumps(status, indent=None, ensure_ascii=False) + '\n')
         status = await minecraft.get_status_pre17()

opengsq/protocols/quake1.py

@@ -9,9 +9,9 @@ class Quake1(ProtocolBase):
     """Quake1 Protocol"""
     full_name = 'Quake1 Protocol'
 
-    def __init__(self, address: str, query_port: int, timeout: float = 5.0):
+    def __init__(self, host: str, port: int, timeout: float = 5.0):
         """Quake1 Query Protocol"""
-        super().__init__(address, query_port, timeout)
+        super().__init__(host, port, timeout)
         self._delimiter1 = b'\\'
         self._delimiter2 = b'\n'
         self._request_header = b'status'
@@ -91,7 +91,7 @@ async def _connect_and_send(self, data):
         # Connect to remote host
         with SocketAsync() as sock:
             sock.settimeout(self._timeout)
-            await sock.connect((self._address, self._query_port))
+            await sock.connect((self._host, self._port))
 
             header = b'\xFF\xFF\xFF\xFF'
 
@@ -118,7 +118,7 @@ async def _connect_and_send(self, data):
     import json
 
     async def main_async():
-        quake1 = Quake1(address='35.185.44.174', query_port=27500, timeout=5.0)
+        quake1 = Quake1(host='35.185.44.174', port=27500, timeout=5.0)
         status = await quake1.get_status()
         print(json.dumps(status, indent=None) + '\n')
 

opengsq/protocols/quake2.py

@@ -8,9 +8,9 @@ class Quake2(Quake1):
     """Quake2 Protocol"""
     full_name = 'Quake2 Protocol'
 
-    def __init__(self, address: str, query_port: int, timeout: float = 5.0):
+    def __init__(self, host: str, port: int, timeout: float = 5.0):
         """Quake2 Query Protocol"""
-        super().__init__(address, query_port, timeout)
+        super().__init__(host, port, timeout)
         self._response_header = 'print\n'
 
     def _parse_players(self, br: BinaryReader) -> list:
@@ -40,7 +40,7 @@ def _parse_players(self, br: BinaryReader) -> list:
     import json
 
     async def main_async():
-        quake2 = Quake2(address='46.165.236.118', query_port=27910, timeout=5.0)
+        quake2 = Quake2(host='46.165.236.118', port=27910, timeout=5.0)
         status = await quake2.get_status()
         print(json.dumps(status, indent=None) + '\n')
 

opengsq/protocols/quake3.py

@@ -8,9 +8,9 @@ class Quake3(Quake2):
     """Quake3 Protocol"""
     full_name = 'Quake3 Protocol'
 
-    def __init__(self, address: str, query_port: int, timeout: float = 5.0):
+    def __init__(self, host: str, port: int, timeout: float = 5.0):
         """Quake3 Query Protocol"""
-        super().__init__(address, query_port, timeout)
+        super().__init__(host, port, timeout)
         self._request_header = b'getstatus'
         self._response_header = 'statusResponse\n'
 
@@ -67,7 +67,7 @@ def strip_colors(text: str):
     import json
 
     async def main_async():
-        quake3 = Quake3(address='85.10.197.106', query_port=27960, timeout=5.0)
+        quake3 = Quake3(host='85.10.197.106', port=27960, timeout=5.0)
         info = await quake3.get_info()
         status = await quake3.get_status()
         print(json.dumps(info, indent=None) + '\n')

opengsq/protocols/raknet.py

@@ -16,7 +16,7 @@ class Raknet(ProtocolBase):
 
     async def get_status(self) -> dict:
         request = self.__ID_UNCONNECTED_PING + self.__TIMESTAMP + self.__OFFLINE_MESSAGE_DATA_ID + self.__CLIENT_GUID
-        response = await SocketAsync.send_and_receive(self._address, self._query_port, self._timeout, request)
+        response = await SocketAsync.send_and_receive(self._host, self._port, self._timeout, request)
 
         br = BinaryReader(response)
         header = br.read_bytes(1)
@@ -66,7 +66,7 @@ async def get_status(self) -> dict:
     import json
 
     async def main_async():
-        raknet = Raknet(address='193.70.94.83', query_port=19132, timeout=5.0)
+        raknet = Raknet(host='193.70.94.83', port=19132, timeout=5.0)
         status = await raknet.get_status()
         print(json.dumps(status, indent=None) + '\n')
 

opengsq/protocols/samp.py

@@ -50,12 +50,12 @@ async def get_rules(self):
 
     async def __send_and_receive(self, data: bytes):
         # Format the address
-        host = SocketAsync.gethostbyname(self._address)
-        packet_header = struct.pack('BBBBH', *map(int, host.split('.') + [self._query_port])) + data
+        host = SocketAsync.gethostbyname(self._host)
+        packet_header = struct.pack('BBBBH', *map(int, host.split('.') + [self._port])) + data
         request = self._request_header + packet_header
 
         # Validate the response
-        response = await SocketAsync.send_and_receive(self._address, self._query_port, self._timeout, request)
+        response = await SocketAsync.send_and_receive(self._host, self._port, self._timeout, request)
         header = response[:len(self._response_header)]
 
         if header != self._response_header:
@@ -73,7 +73,7 @@ def __read_string(self, br: BinaryReader, read_offset=1):
     import json
 
     async def main_async():
-        samp = Samp(address='51.254.178.238', query_port=7777, timeout=5.0)
+        samp = Samp(host='51.254.178.238', port=7777, timeout=5.0)
         status = await samp.get_status()
         print(json.dumps(status, indent=None) + '\n')
         players = await samp.get_players()

opengsq/protocols/satisfactory.py

@@ -19,7 +19,7 @@ async def get_status(self) -> dict:
 
         # Send message id, protocol version
         request = struct.pack('2b', 0, 0) + 'opengsq'.encode()
-        response = await SocketAsync.send_and_receive(self._address, self._query_port, self._timeout, request)
+        response = await SocketAsync.send_and_receive(self._host, self._port, self._timeout, request)
         br = BinaryReader(response)
         header = br.read_byte()
 
@@ -42,7 +42,7 @@ async def get_status(self) -> dict:
     import json
 
     async def main_async():
-        satisfactory = Satisfactory(address='delta3.ptse.host', query_port=15777, timeout=5.0)
+        satisfactory = Satisfactory(host='delta3.ptse.host', port=15777, timeout=5.0)
         status = await satisfactory.get_status()
         print(json.dumps(status, indent=None) + '\n')
 

opengsq/protocols/source.py

@@ -189,7 +189,7 @@ async def __connect_and_send_challenge(self, header: __RequestHeader) -> bytes:
         # Connect to remote host
         with SocketAsync() as sock:
             sock.settimeout(self._timeout)
-            await sock.connect((self._address, self._query_port))
+            await sock.connect((self._host, self._port))
 
             # Send and receive
             request_base = b'\xFF\xFF\xFF\xFF' + header
@@ -348,7 +348,7 @@ async def authenticate(self, password: str):
             # Connect
             self._sock = SocketAsync(SocketKind.SOCK_STREAM)
             self._sock.settimeout(self._timeout)
-            await self._sock.connect((self._address, self._query_port))
+            await self._sock.connect((self._host, self._port))
 
             # Send password
             id = random.randrange(4096)
@@ -459,7 +459,7 @@ def get_bytes(self):
     import json
 
     async def main_async():
-        source = Source(address='209.205.114.187', query_port=27015, timeout=5.0)
+        source = Source(host='209.205.114.187', port=27015, timeout=5.0)
         info = await source.get_info()
         print(json.dumps(info, indent=None, ensure_ascii=False) + '\n')
         players = await source.get_players()

opengsq/protocols/teamspeak3.py

@@ -6,8 +6,8 @@ class Teamspeak3(ProtocolBase):
     """Teamspeak 3 Protocol"""
     full_name = 'Teamspeak 3 Protocol'
 
-    def __init__(self, address: str, query_port: int, voice_port: int, timeout: float = 5):
-        super().__init__(address, query_port, timeout)
+    def __init__(self, host: str, port: int, voice_port: int, timeout: float = 5):
+        super().__init__(host, port, timeout)
         self._voice_port = voice_port
 
     async def get_info(self):
@@ -25,7 +25,7 @@ async def get_channels(self):
     async def __send_and_receive(self, data: bytes):
         with SocketAsync(SocketKind.SOCK_STREAM) as sock:
             sock.settimeout(self._timeout)
-            await sock.connect((self._address, self._query_port))
+            await sock.connect((self._host, self._port))
 
             # b'TS3\n\rWelcome to the TeamSpeak 3 ServerQuery interface,
             # type "help" for a list of commands and "help <command>" for information on a specific command.\n\r'
@@ -61,7 +61,7 @@ def __parse_kvs(self, response: bytes):
     import json
 
     async def main_async():
-        teamspeak3 = Teamspeak3(address='145.239.200.2', query_port=10011, voice_port=9987, timeout=5.0)
+        teamspeak3 = Teamspeak3(host='145.239.200.2', port=10011, voice_port=9987, timeout=5.0)
         info = await teamspeak3.get_info()
         print(json.dumps(info, indent=None) + '\n')
         clients = await teamspeak3.get_clients()