Change async_rcon to class

By changing this to a class we clean up code duplication. Now we just declare the host, port, and password then call the method with just a command and arguments. tested to confirm working

README.md

@@ -35,13 +35,19 @@ If you prefer to use Source RCON in an asynchronous environment, you can use
 `rcon()`.
 
 ```python
-from rcon.source import rcon
+from rcon.source import Rcon
 
-response = await rcon(
+response = await Rcon.rcon(
     'some_command', 'with', 'some', 'arguments',
     host='127.0.0.1', port=5000, passwd='mysecretpassword'
 )
 print(response)
+
+or
+
+connect = Rcon('127.0.0.1', 12715, 'mysecretpassword')
+response = await connect.rcon('some_command','with', 'some', 'arguments')
+print(response)
 ```
 
 ### BattlEye RCon

rcon/__init__.py

@@ -4,7 +4,7 @@ from typing import Any, Coroutine
 from warnings import warn
 
 from rcon.exceptions import EmptyResponse, SessionTimeout, WrongPassword
-from rcon.source import rcon as _rcon
+from rcon.source import Rcon as _rcon
 from rcon.source import Client as _Client
 
 

rcon/source/__init__.py

@@ -1,7 +1,7 @@
 """Source RCON implementation."""
 
-from rcon.source.async_rcon import rcon
+from rcon.source.async_rcon import Rcon
 from rcon.source.client import Client
 
 
-__all__ = ["Client", "rcon"]
+__all__ = ["Client", "Rcon"]

rcon/source/async_rcon.py

@@ -6,77 +6,97 @@ from rcon.exceptions import SessionTimeout, WrongPassword
 from rcon.source.proto import Packet, Type
 
 
-__all__ = ["rcon"]
+__all__ = ["Rcon"]
-
+
-
+
-async def close(writer: StreamWriter) -> None:
+class Rcon:
-    """Close socket asynchronously."""
+    """
-
+    Set's the variables needed for RCON connection
-    writer.close()
+    """
-    await writer.wait_closed()
+    def __init__(self,
+                 host: str,
+                 port: int = 27015,
+                 password: str = ''
+                 ):
+
+        self.host = host
+        self.port = port
+        self.password = password
+
+    async def close(self, writer: StreamWriter) -> None:
+        """Close socket asynchronously."""
+
+        writer.close()
+        await writer.wait_closed()
+
+    async def communicate(
+        self,
+        reader: StreamReader,
+        writer: StreamWriter,
+        packet: Packet,
+        *,
+        frag_threshold: int = 4096,
+        frag_detect_cmd: str = "",
+    ) -> Packet:
+        """Make an asynchronous request."""
+
+        writer.write(bytes(packet))
+        await writer.drain()
+        response = await Packet.aread(reader)
 
+        if len(response.payload) < frag_threshold:
+            return response
 
-async def communicate(
+        writer.write(bytes(Packet.make_command(frag_detect_cmd)))
-    reader: StreamReader,
+        await writer.drain()
-    writer: StreamWriter,
-    packet: Packet,
-    *,
-    frag_threshold: int = 4096,
-    frag_detect_cmd: str = "",
-) -> Packet:
-    """Make an asynchronous request."""
 
-    writer.write(bytes(packet))
+        while (successor := await Packet.aread(reader)).id == response.id:
-    await writer.drain()
+            response += successor
-    response = await Packet.aread(reader)
 
-    if len(response.payload) < frag_threshold:
         return response
 
-    writer.write(bytes(Packet.make_command(frag_detect_cmd)))
+    async def rcon(
-    await writer.drain()
+        self,
-
+        command: str,
-    while (successor := await Packet.aread(reader)).id == response.id:
+        *arguments: str,
-        response += successor
+        host: str = None,
-
+        port: int = None,
-    return response
+        passwd: str = None,
-
+        encoding: str = "utf-8",
-
+        frag_threshold: int = 4096,
-async def rcon(
+        frag_detect_cmd: str = "",
-    command: str,
+    ) -> str:
-    *arguments: str,
+        """Run a command asynchronously."""
-    host: str,
+        try:
-    port: int,
+            host = host or self.host
-    passwd: str,
+            port = port or self.port
-    encoding: str = "utf-8",
+            passwd = passwd or self.password
-    frag_threshold: int = 4096,
+        except AttributeError:
-    frag_detect_cmd: str = "",
+            return print("Make sure you declare the host, port, or password.")
-) -> str:
+
-    """Run a command asynchronously."""
+        reader, writer = await open_connection(host, port)
-
+        response = await self.communicate(
-    reader, writer = await open_connection(host, port)
+            reader,
-    response = await communicate(
+            writer,
-        reader,
+            Packet.make_login(passwd, encoding=encoding),
-        writer,
+            frag_threshold=frag_threshold,
-        Packet.make_login(passwd, encoding=encoding),
+            frag_detect_cmd=frag_detect_cmd,
-        frag_threshold=frag_threshold,
+        )
-        frag_detect_cmd=frag_detect_cmd,
+
-    )
+        # Wait for SERVERDATA_AUTH_RESPONSE according to:
-
+        # https://developer.valvesoftware.com/wiki/Source_RCON_Protocol
-    # Wait for SERVERDATA_AUTH_RESPONSE according to:
+        while response.type != Type.SERVERDATA_AUTH_RESPONSE:
-    # https://developer.valvesoftware.com/wiki/Source_RCON_Protocol
+            response = await Packet.aread(reader)
-    while response.type != Type.SERVERDATA_AUTH_RESPONSE:
+
-        response = await Packet.aread(reader)
+        if response.id == -1:
-
+            await self.close(writer)
-    if response.id == -1:
+            raise WrongPassword()
-        await close(writer)
+
-        raise WrongPassword()
+        request = Packet.make_command(command, *arguments, encoding=encoding)
-
+        response = await self.communicate(reader, writer, request)
-    request = Packet.make_command(command, *arguments, encoding=encoding)
+        await self.close(writer)
-    response = await communicate(reader, writer, request)
+
-    await close(writer)
+        if response.id != request.id:
-
+            raise SessionTimeout()
-    if response.id != request.id:
+
-        raise SessionTimeout()
+        return response.payload.decode(encoding)
-
-    return response.payload.decode(encoding)