aiosatisfactory 0.1.0__py3-none-any.whl

aiosatisfactory/__init__.py

@@ -0,0 +1,21 @@
+import aiohttp
+from .lightweight import LightweightAPI
+from .https import HttpsAPI
+
+
+class SatisfactoryServer:
+    def __init__(self, host: str, port: int = 7777, self_signed_certificate: bool = True, session: aiohttp.ClientSession | None = None, api_token: str = ""):
+        self._lightweight = LightweightAPI(host, port)
+        if session is None:
+            self._https = None
+        else:
+            self._https = HttpsAPI(self_signed_certificate, host, port, session, api_token)
+
+    @property
+    def lightweight(self) -> LightweightAPI:
+        return self._lightweight
+    
+    @property
+    def https(self) -> HttpsAPI | None:
+        return self._https
+

aiosatisfactory/https/__init__.py

@@ -0,0 +1,36 @@
+import ssl
+import aiohttp
+from .api import ApiEndpoints
+
+class HttpsAPI:
+
+    def __init__(self, self_signed_certificate: bool, host: str, port: int, session: aiohttp.ClientSession, api_token: str):
+        self._host = host
+        self._port = port
+        self._api_token = api_token
+        self._headers = {
+            'content-type': 'application/json',
+        }
+
+        self._ssl_context = ssl.create_default_context()
+        if self_signed_certificate:
+            self._ssl_context.check_hostname = False
+            self._ssl_context.verify_mode = ssl.CERT_NONE
+
+        if api_token:
+            self._headers["Authorization"] = f"Bearer {self._api_token}"
+
+        self._url = f"https://{self._host}:{self._port}/api/v1"
+
+        self._api = ApiEndpoints(session, self._url, self._headers, self._ssl_context)
+    
+    @property
+    def api_token(self, new_token: str = "") -> str:
+        if new_token:
+            self._api_token = new_token
+            self._headers["Authorization"] = f"Bearer {self._api_token}"
+        return self._api_token
+
+    @property
+    def api(self) -> ApiEndpoints:
+        return self._api

aiosatisfactory/https/api.py

@@ -0,0 +1,375 @@
+import json, aiohttp
+import ssl
+from .models import (
+    BaseResponse,
+    HealthCheckResponse,
+    PasswordlessLoginResponse,
+    PasswordLoginResponse,
+    QueryServerStateResponse,
+    GetServerOptionsResponse,
+    GetAdvancedGameSettingsResponse,
+    ClaimServerResponse,
+    RunCommandResponse,
+    ServerNewGameData,
+    EnumerateSessionsResponse,
+    DownloadSaveGameResponse,
+    ErrorResponse
+)
+
+class ApiEndpoints():
+    def __init__(self, session: aiohttp.ClientSession, url: str, headers: dict[str, str], ssl_context: ssl.SSLContext):
+        self._session = session
+        self._url = url
+        self._headers = headers
+        self._ssl_context = ssl_context
+
+    async def _post(self, function: str, data: dict[str, str] = {}) -> aiohttp.ClientResponse:
+
+        return await self._session.post(
+            self._url,
+            json={"function": function, "data": data},
+            headers=self._headers,
+            ssl=self._ssl_context
+        )
+
+    def _raise_error(self, response: aiohttp.ClientResponse, data: dict[str, str]) -> None:
+        if response.status >= 400:
+            raise ErrorResponse(data["errorCode"], data.get("errorMessage"), data.get("errorData"))
+
+
+    async def health_check(self, client_custom_data: str = "") -> HealthCheckResponse:
+        response = await self._post(
+            "HealthCheck",
+            {
+                "ClientCustomData": client_custom_data
+            }
+        )
+        data = await response.json()
+        self._raise_error(response, data)
+        data = data["data"]
+        return HealthCheckResponse(
+            response.status,
+            data["health"],
+            data["serverCustomData"]
+        )
+
+
+
+    async def verify_authentication_token(self) -> BaseResponse:
+        response = await self._post("VerifyAuthenticationToken")
+        if response.status >= 400:
+            data = await response.json()
+            self._raise_error(response, data)
+        return BaseResponse(response.status)
+
+
+    async def passwordless_login(self, minimum_privilege_level: str) -> PasswordlessLoginResponse:
+        response = await self._post(
+            "PasswordlessLogin",
+            {
+                "MinimumPrivilegeLevel": minimum_privilege_level
+            }
+        )
+        data = await response.json()
+        self._raise_error(response, data)
+        data = data["data"]
+        return PasswordlessLoginResponse(
+            response.status,
+            data["authenticationToken"]
+        )
+
+
+
+    async def passwordlogin(self, minimum_privilege_level: str, password: str) -> PasswordLoginResponse:
+        response = await self._post(
+            "PasswordLogin",
+            {
+                "MinimumPrivilegeLevel": minimum_privilege_level,
+                "Password": password
+            }
+        )
+        data = await response.json()
+        self._raise_error(response, data)
+        data = data["data"]
+        return PasswordLoginResponse(
+            response.status,
+            data["authenticationToken"]
+        )
+
+
+
+    async def query_server_state(self) -> QueryServerStateResponse:
+        response = await self._post("QueryServerState")
+        data = await response.json()
+        self._raise_error(response, data)
+        data = data["ServerGameState"]
+        return QueryServerStateResponse(
+            response.status,
+            data["ActiveSessionName"],
+            data["NumConnectedPlayers"],
+            data["PlayerLimit"],
+            data["TechTier"],
+            data["ActiveSchematic"],
+            data["GamePhase"],
+            data["IsGameRunning"],
+            data["TotalGameDuration"],
+            data["IsGamePaused"],
+            data["AverageTickRate"],
+            data["AutoLoadSessionName"]
+        )
+
+
+
+    async def get_server_options(self) -> GetServerOptionsResponse:
+        response = await self._post("GetServerOptions")
+        data = await response.json()
+        self._raise_error(response, data)
+        return GetServerOptionsResponse(
+            response.status,
+            data["ServerOptions"],
+            data["PendingServerOptions"]
+        )
+
+
+
+    async def get_advanced_game_settings(self) -> GetAdvancedGameSettingsResponse:
+        response = await self._post("GetAdvancedGameSettings")
+        data = await response.json()
+        self._raise_error(response, data)
+        return GetAdvancedGameSettingsResponse(
+            response.status,
+            data["CreativeModeEnabled"],
+            data["AdvancedGameSettings"]
+            )
+
+
+
+    async def apply_advanced_game_settings(self, applied_advanced_game_settings: dict[str, str]) -> BaseResponse:
+        response = await self._post(
+            "ApplyAdvancedGameSettings",
+            {
+                "AppliedAdvancedGameSettings": json.dumps(applied_advanced_game_settings)
+            }
+        )
+        data = await response.json()
+        self._raise_error(response, data)
+        return BaseResponse(response.status)
+
+
+
+    async def claim_server(self, server_name: str, admin_password: str) -> ClaimServerResponse:
+        response = await self._post(
+            "ClaimServer",
+            {
+                "ServerName": server_name,
+                "AdminPassword": admin_password
+            }
+        )
+        data = await response.json()
+        self._raise_error(response, data)
+        return ClaimServerResponse(
+            response.status,
+            data["authenticationToken"]
+        )
+
+
+
+    async def rename_server(self, server_name: str) -> BaseResponse:
+        response = await self._post(
+            "RenameServer",
+            {
+                "ServerName": server_name
+            }
+        )
+        data = await response.json()
+        self._raise_error(response, data)
+        return BaseResponse(response.status)
+
+
+
+    async def set_client_password(self, password: str) -> BaseResponse:
+        response = await self._post(
+            "SetClientPassword",
+            {
+                "Password": password
+            }
+        )
+        data = await response.json()
+        self._raise_error(response, data)
+        return BaseResponse(response.status)
+
+
+
+    async def set_admin_password(self, password: str, authentication_token: str) -> BaseResponse:
+        response = await self._post(
+            "SetAdminPassword",
+            {
+                "Password": password,
+                "AuthenticationToken": authentication_token #??? - We have to generate a new token? - Maybe the documentation is wrong and this field is returned from the server?
+            }
+        ) 
+        data = await response.json()
+        self._raise_error(response, data)
+        return BaseResponse(response.status)
+
+
+
+    async def set_auto_load_session_name(self, session_name: str) -> BaseResponse:
+        response = await self._post(
+            "SetAutoLoadSessionName",
+            {
+                "SessionName": session_name
+            }
+        )
+        data = await response.json()
+        self._raise_error(response, data)
+        return BaseResponse(response.status)
+
+
+
+    async def run_command(self, command: str) -> RunCommandResponse:
+        response = await self._post(
+            "RunCommand",
+            {
+                "Command": command
+            }
+        )
+        data = await response.json()
+        self._raise_error(response, data)
+        return RunCommandResponse(
+            response.status,
+            data["CommandResult"],
+            data["ReturnValue"]
+        )
+
+
+
+    async def shutdown(self) -> BaseResponse:
+        response = await self._post("Shutdown")
+        data = await response.json()
+        self._raise_error(response, data)
+        return BaseResponse(response.status)
+
+
+
+    async def apply_server_options(self, updated_server_options: dict[str, str]) -> BaseResponse:
+        response = await self._post(
+            "ApplyServerOptions",
+            {
+                "UpdatedServerOptions": json.dumps(updated_server_options)
+            }
+        )
+        data = await response.json()
+        self._raise_error(response, data)
+        return BaseResponse(response.status)
+
+
+
+    async def create_new_game(self, new_game_data: ServerNewGameData) -> BaseResponse:
+        response = await self._post(
+            "CreateNewGame",
+            {
+                "NewGameData": json.dumps(new_game_data)
+            }
+        )
+        data = await response.json()
+        self._raise_error(response, data)
+        return BaseResponse(response.status)
+
+
+
+    async def save_game(self, save_name: str) -> BaseResponse:
+        response = await self._post(
+            "SaveGame",
+            {
+                "SaveName": save_name
+            }
+        )
+        data = await response.json()
+        self._raise_error(response, data)
+        return BaseResponse(response.status)
+
+
+
+    async def delete_save_file(self, save_name: str) -> BaseResponse:
+        response = await self._post(
+            "DeleteSaveFile",
+            {
+                "SaveName": save_name
+            }
+        )
+        data = await response.json()
+        self._raise_error(response, data)
+        return BaseResponse(response.status)
+
+
+
+    async def delete_save_session(self, session_name: str) -> BaseResponse:
+        response = await self._post(
+            "DeleteSaveSession",
+            {
+                "SessionName": session_name
+            }
+        )
+        data = await response.json()
+        self._raise_error(response, data)
+        return BaseResponse(response.status)
+
+
+
+    async def enumerate_sessions(self) -> EnumerateSessionsResponse:
+        response = await self._post("EnumerateSessions")
+        data = await response.json()
+        self._raise_error(response, data)
+        return EnumerateSessionsResponse(
+            response.status,
+            data["Sessions"],
+            data["CurrentSessionIndex"]
+        )
+
+
+
+    async def load_game(self, save_name: str, enable_advanced_game_settings: bool) -> BaseResponse:
+        response = await self._post(
+            "LoadGame",
+            {
+                "SaveName": save_name,
+                "EnableAdvancedGameSettings": str(enable_advanced_game_settings)
+            }
+        )
+        data = await response.json()
+        self._raise_error(response, data)
+        return BaseResponse(response.status)
+
+
+
+    #TODO
+    async def upload_save_game(self, save_name: str, load_save_game: bool, enable_advanced_game_settings: bool) -> BaseResponse:
+        response = await self._post(
+            "UploadSaveGame",
+            {
+                "SaveName": save_name,
+                "LoadSaveGame": str(load_save_game),
+                "EnableAdvancedGameSettings": str(enable_advanced_game_settings)
+            }
+        )
+        data = await response.json()
+        self._raise_error(response, data)
+        return BaseResponse(response.status)
+
+
+
+    #TODO
+    async def download_save_game(self, save_name: str) -> DownloadSaveGameResponse:
+        response = await self._post(
+            "DownloadSaveGame",
+            {
+                "SaveName": save_name
+            }
+        )
+        data = await response.json()
+        self._raise_error(response, data)
+        return DownloadSaveGameResponse(
+            response.status,
+            data["SaveData"]
+        )

aiosatisfactory/https/models.py

@@ -0,0 +1,118 @@
+from dataclasses import dataclass
+
+
+
+@dataclass(slots=True)
+class BaseResponse:
+    status_code: int
+
+
+
+@dataclass(slots=True)
+class HealthCheckResponse(BaseResponse):
+    health: str
+    server_custom_data: str
+
+
+
+@dataclass(slots=True)
+class PasswordlessLoginResponse(BaseResponse):
+    authentication_token: str
+
+
+
+@dataclass(slots=True)
+class PasswordLoginResponse(BaseResponse):
+    authentication_token: str
+
+
+
+@dataclass(slots=True)
+class QueryServerStateResponse(BaseResponse):
+    active_session_name: str
+    num_connected_players: int
+    player_limit: int
+    tech_tier: int
+    active_schematic: str
+    game_phase: str
+    is_game_running: bool
+    total_game_duration: int
+    is_game_paused: bool
+    average_tick_rate: float
+    auto_load_session_name: str
+
+
+
+@dataclass(slots=True)
+class GetServerOptionsResponse(BaseResponse):
+    server_options: dict[str, str]
+    pending_server_options: dict[str, str]
+
+
+
+@dataclass(slots=True)
+class GetAdvancedGameSettingsResponse(BaseResponse):
+    creative_mode_enabled: bool
+    advanced_game_settings: dict[str, str]
+
+
+
+@dataclass(slots=True)
+class ClaimServerResponse(BaseResponse):
+    authentication_token: str
+
+
+
+@dataclass(slots=True)
+class RunCommandResponse(BaseResponse):
+    command_result: str
+    return_value: bool
+
+
+
+@dataclass(slots=True)
+class ServerNewGameData:
+    session_name: str
+    map_name: str
+    starting_location: str
+    skip_onboarding: bool
+    advanced_game_settings: dict[str, str]
+    custom_options_only_for_modding: dict[str, str]
+
+
+
+@dataclass(slots=True)
+class SaveHeader:
+    save_version: int
+    build_version: int
+    save_name: str
+    map_name: str
+    map_options: str
+    session_name: str
+    play_duration_seconds: int
+    save_date_time: str
+    is_modded_save: bool
+    is_edited_save: bool
+    is_creative_mode_enabled: bool
+
+@dataclass(slots=True)
+class SessionSaveStruct:
+    session_name: str
+    save_headers: list[SaveHeader]
+
+@dataclass(slots=True)
+class EnumerateSessionsResponse(BaseResponse):
+    sessions: list[SessionSaveStruct]
+    current_session_index: int
+
+@dataclass(slots=True)
+class DownloadSaveGameResponse(BaseResponse):
+    save_data: bytes
+
+
+
+@dataclass(slots=True)
+class ErrorResponse(Exception):
+    error_code: str
+    error_message: str | None = None
+    error_details: str | None = None

aiosatisfactory/lightweight/__init__.py

@@ -0,0 +1,38 @@
+import struct
+from .udp import udp_query
+from .response import ServerStateResponse
+from .request import ServerStateRequest
+
+from .const import (
+    POLL_FORMAT,
+    PROTOCOL_MAGIC,
+    MESSAGE_TYPE_POLL,
+    PROTOCOL_VERSION,
+    TERMINATOR_BYTE
+)
+
+class LightweightAPIResult():
+    def __init__(self, request: ServerStateRequest, response: ServerStateResponse):
+        self._request = request
+        self._response = response
+
+    @property
+    def request(self) -> ServerStateRequest:
+        return self._request
+
+    @property
+    def response(self) -> ServerStateResponse:
+        return self._response
+
+class LightweightAPI():
+    def __init__(self, host: str, port: int):
+        self._host = host
+        self._port = port
+
+    async def query(self, Cookie: int) -> LightweightAPIResult | None:
+
+        request = struct.pack(POLL_FORMAT, PROTOCOL_MAGIC, MESSAGE_TYPE_POLL, PROTOCOL_VERSION, Cookie, TERMINATOR_BYTE)
+        response = await udp_query(self._host, self._port, request)
+        if response is None:
+            return None
+        return LightweightAPIResult(ServerStateRequest(request), ServerStateResponse(response))

aiosatisfactory/lightweight/const.py

@@ -0,0 +1,75 @@
+"""Constants for Satisfactory LightWeight Query protocol."""
+
+"""
+All the data in this protocol is in little-endian byte order as stated in the official documentation
+The conversion between the documentation DataType and struct formats is as follows:
+- uint8  -> B
+- uint16 -> H
+- uint32 -> L
+- uint64 -> Q
+- uint8[] -> s
+"""
+
+"""General purpose fields and formats."""
+
+PROTOCOL_MAGIC: int = 0xF6D5
+PROTOCOL_MAGIC_FORMAT: str = "<H"
+PROTOCOL_MAGIC_OFFSET: int = 0
+
+MESSAGE_TYPE_FORMAT: str = "<B"
+MESSAGE_TYPE_OFFSET: int = 2
+
+PROTOCOL_VERSION: int = 1
+PROTOCOL_VERSION_FORMAT: str = "<B"
+PROTOCOL_VERSION_OFFSET: int = 3
+
+# The payload starts after the 3-byte header, we use this constant to have a direct reference to the documentation offsets
+PAYLOAD_START_BYTE: int = 4
+
+# The payload always starts with a cookie to identify the request/response pair
+COOKIE_FORMAT: str = "<Q"
+COOKIE_OFFSET: int = PAYLOAD_START_BYTE + 0
+
+# The last byte is always the terminator byte
+TERMINATOR_BYTE: int = 0x01
+TERMINATOR_BYTE_FORMAT: str = "<B"
+TERMINATOR_BYTE_OFFSET: int = -1
+
+"""Poll specific field formats and offsets."""
+
+MESSAGE_TYPE_POLL: int = 0
+
+POLL_FORMAT: str = "<HBBQB"
+
+SUB_STATES_STRUCTURE_SIZE: int = 3
+
+"""Response specific field formats and offsets."""
+
+MESSAGE_TYPE_RESPONSE: int = 1
+
+SERVER_STATE_FORMAT: str = "<B"
+SERVER_STATE_OFFSET: int = PAYLOAD_START_BYTE + 8
+
+SERVER_NET_CL_FORMAT: str = "<L"
+SERVER_NET_CL_OFFSET: int = PAYLOAD_START_BYTE + 9
+
+SERVER_FLAGS_FORMAT: str = "<Q"
+SERVER_FLAGS_OFFSET: int = PAYLOAD_START_BYTE + 13
+
+NUM_SUB_STATES_FORMAT: str = "<B"
+NUM_SUB_STATES_OFFSET: int = PAYLOAD_START_BYTE + 21
+
+# The sub-states section directly start with the first sub state ID
+SUB_STATE_ID_FORMAT: str = "<B"
+SUB_STATE_ID_OFFSET: int = PAYLOAD_START_BYTE + 22
+
+# The sub-state version follows after it's ID, the documentation has a typo here saying there is an 8 bytes offset
+SUB_STATE_VERSION_FORMAT: str = "<H"
+BASE_SUB_STATE_VERSION_OFFSET: int = PAYLOAD_START_BYTE + 22 + 1
+
+SERVER_NAME_LENGTH_FORMAT: str = "<H"
+BASE_SERVER_NAME_LENGTH_OFFSET: int = PAYLOAD_START_BYTE + 22
+
+# {} is to be replaced with the length of the server name + 1
+SERVER_NAME_FORMAT: str = "<{}s"
+BASE_SERVER_NAME_OFFSET: int = PAYLOAD_START_BYTE + 22 + 1

aiosatisfactory/lightweight/request.py

@@ -0,0 +1,33 @@
+import struct
+
+from .const import (
+    PROTOCOL_MAGIC_FORMAT, PROTOCOL_MAGIC_OFFSET,
+    MESSAGE_TYPE_FORMAT, MESSAGE_TYPE_OFFSET,
+    PROTOCOL_VERSION_FORMAT, PROTOCOL_VERSION_OFFSET,
+    COOKIE_FORMAT, COOKIE_OFFSET,
+    TERMINATOR_BYTE_FORMAT, TERMINATOR_BYTE_OFFSET,
+)
+
+class ServerStateRequest:
+    def __init__(self, raw_request: bytes):
+        self.raw_request = raw_request
+
+    @property
+    def ProtocolMagic(self) -> str:
+        return struct.unpack_from(PROTOCOL_MAGIC_FORMAT, self.raw_request, PROTOCOL_MAGIC_OFFSET)[0]
+    
+    @property
+    def MessageType(self) -> int:
+        return struct.unpack_from(MESSAGE_TYPE_FORMAT, self.raw_request, MESSAGE_TYPE_OFFSET)[0]
+
+    @property
+    def ProtocolVersion(self) -> int:
+        return struct.unpack_from(PROTOCOL_VERSION_FORMAT, self.raw_request, PROTOCOL_VERSION_OFFSET)[0]
+
+    @property
+    def Cookie(self) -> int:
+        return struct.unpack_from(COOKIE_FORMAT, self.raw_request, COOKIE_OFFSET)[0]
+    
+    @property
+    def TerminatorByte(self) -> int:
+        return struct.unpack_from(TERMINATOR_BYTE_FORMAT, self.raw_request, TERMINATOR_BYTE_OFFSET)[0]

aiosatisfactory/lightweight/response.py

@@ -0,0 +1,80 @@
+import struct
+
+from .const import (
+    PROTOCOL_MAGIC_FORMAT, PROTOCOL_MAGIC_OFFSET,
+    MESSAGE_TYPE_FORMAT, MESSAGE_TYPE_OFFSET,
+    PROTOCOL_VERSION_FORMAT, PROTOCOL_VERSION_OFFSET,
+    COOKIE_FORMAT, COOKIE_OFFSET,
+    SERVER_STATE_FORMAT, SERVER_STATE_OFFSET,
+    SERVER_NET_CL_FORMAT, SERVER_NET_CL_OFFSET,
+    SERVER_FLAGS_FORMAT, SERVER_FLAGS_OFFSET,
+    NUM_SUB_STATES_FORMAT, NUM_SUB_STATES_OFFSET,
+    SUB_STATE_ID_FORMAT, SUB_STATE_ID_OFFSET,
+    SUB_STATE_VERSION_FORMAT, BASE_SUB_STATE_VERSION_OFFSET,
+    SERVER_NAME_LENGTH_FORMAT, BASE_SERVER_NAME_LENGTH_OFFSET,
+    SERVER_NAME_FORMAT, BASE_SERVER_NAME_OFFSET,
+    TERMINATOR_BYTE_FORMAT, TERMINATOR_BYTE_OFFSET,
+    SUB_STATES_STRUCTURE_SIZE
+)
+
+class ServerStateResponse:
+
+    def __init__(self, raw_response: bytes):
+        self.raw_response = raw_response
+
+    @property
+    def ProtocolMagic(self) -> str:
+        return struct.unpack_from(PROTOCOL_MAGIC_FORMAT, self.raw_response, PROTOCOL_MAGIC_OFFSET)[0]
+    
+    @property
+    def MessageType(self) -> int:
+        return struct.unpack_from(MESSAGE_TYPE_FORMAT, self.raw_response, MESSAGE_TYPE_OFFSET)[0]
+
+    @property
+    def ProtocolVersion(self) -> int:
+        return struct.unpack_from(PROTOCOL_VERSION_FORMAT, self.raw_response, PROTOCOL_VERSION_OFFSET)[0]
+
+    @property
+    def Cookie(self) -> int:
+        return struct.unpack_from(COOKIE_FORMAT, self.raw_response, COOKIE_OFFSET)[0]
+
+    @property
+    def ServerState(self) -> int:
+        return struct.unpack_from(SERVER_STATE_FORMAT, self.raw_response, SERVER_STATE_OFFSET)[0]
+
+    @property
+    def ServerNetCL(self) -> int:
+        return struct.unpack_from(SERVER_NET_CL_FORMAT, self.raw_response, SERVER_NET_CL_OFFSET)[0]
+
+    @property
+    def ServerFlags(self) -> int:
+        return struct.unpack_from(SERVER_FLAGS_FORMAT, self.raw_response, SERVER_FLAGS_OFFSET)[0]
+
+    @property
+    def NumSubStates(self) -> int:
+        return struct.unpack_from(NUM_SUB_STATES_FORMAT, self.raw_response, NUM_SUB_STATES_OFFSET)[0]
+
+    @property
+    def SubStates(self) -> list[tuple[int, int]]:
+        sub_states: list[tuple[int, int]] = []
+        for i in range(self.NumSubStates):
+            sub_state = (
+                struct.unpack_from(SUB_STATE_ID_FORMAT, self.raw_response, SUB_STATE_ID_OFFSET + i * SUB_STATES_STRUCTURE_SIZE)[0],
+                struct.unpack_from(SUB_STATE_VERSION_FORMAT, self.raw_response, BASE_SUB_STATE_VERSION_OFFSET + i * SUB_STATES_STRUCTURE_SIZE)[0]
+            )
+            sub_states.append(sub_state)
+        return sub_states
+
+    @property
+    def ServerNameLength(self) -> int:
+        return struct.unpack_from(SERVER_NAME_LENGTH_FORMAT, self.raw_response, BASE_SERVER_NAME_LENGTH_OFFSET + self.NumSubStates * SUB_STATES_STRUCTURE_SIZE)[0]
+
+    @property
+    def ServerName(self) -> str:
+        calculated_server_name_format = SERVER_NAME_FORMAT.format(self.ServerNameLength + 1)
+        calculated_server_name_offset = BASE_SERVER_NAME_OFFSET + self.NumSubStates * SUB_STATES_STRUCTURE_SIZE
+        return struct.unpack_from(calculated_server_name_format, self.raw_response, calculated_server_name_offset)[0].decode('utf-8')
+
+    @property
+    def TerminatorByte(self) -> int:
+        return struct.unpack_from(TERMINATOR_BYTE_FORMAT, self.raw_response, TERMINATOR_BYTE_OFFSET)[0]

aiosatisfactory/lightweight/udp.py

@@ -0,0 +1,21 @@
+import asyncio
+
+async def udp_query(host: str, port: int, data: bytes, timeout: float = 2.0) -> bytes | None:
+
+    async_loop = asyncio.get_running_loop()
+    future = async_loop.create_future()
+        
+    class UdpProtocol(asyncio.DatagramProtocol):
+        def datagram_received(self, data: bytes, addr: tuple[str, int]):
+            future.set_result(data)
+
+    transport, _ = await async_loop.create_datagram_endpoint(UdpProtocol, remote_addr=(host, port))
+
+    transport.sendto(data)
+
+    try:
+        return await asyncio.wait_for(future, timeout)
+    except TimeoutError:
+        return None
+    finally:
+        transport.close()

aiosatisfactory-0.1.0.dist-info/METADATA

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: aiosatisfactory
+Version: 0.1.0
+Summary: Async client for Satisfactory dedicated server APIs
+Author: Rikys
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Rikys/aiosatisfactory
+Project-URL: Documentation, https://github.com/Rikys/aiosatisfactory#readme
+Project-URL: Issues, https://github.com/Rikys/aiosatisfactory/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9.0
+Dynamic: license-file
+
+# aiosatisfactory
+
+This is an async Python library for Satisfactory dedicated server's APIs.
+
+This work is based off the official documentation that is provided with the game files or is also available on the official [wiki](https://satisfactory.wiki.gg)
+
+## Lightweight API [(docs)](https://satisfactory.wiki.gg/wiki/Dedicated_servers/Lightweight_Query_API)
+This API should be used to poll the server state before making most of the https requests \
+No errors are raised but you must check if the query was succesful
+
+### Usage:
+```python
+from aiosatisfactory import SatisfactoryServer
+import time
+
+client = SatisfactoryServer("server.ip")
+query = await client.lightweight.query(time.time_ns()) #We use time to generate a Cookie
+    if query is not None:
+        print(query.response)
+```
+
+## Https API [(docs)](https://satisfactory.wiki.gg/wiki/Dedicated_servers/HTTPS_API)
+This API requires the *session* parameter to be set in the *SatisfactoryServer* constructor \
+It does raise an *ErrorResponse* exeption if the function you try to execute fails
+
+### Usage:
+```python
+import asyncio
+from aiosatisfactory import SatisfactoryServer
+
+async def main():
+
+    with aiohttp.ClientSession() as session:
+        client = SatisfactoryServer("server.ip", session=session)
+        try:
+            response = await client.https.api.health_check()
+            print(response.health)
+        except ErrorResponse as e:
+            print(f"Error: {e.error_code, e.error_message, e.error_details}")
+
+asyncio.run(main())
+```

aiosatisfactory-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+aiosatisfactory/__init__.py,sha256=TtZYPvyXN0BC5mk7lBMP6yqPEQtez4nKpod-OiPDyPc,669
+aiosatisfactory/https/__init__.py,sha256=rowIX18jcfJnptWdXddDuKcd0Ff6hdzRnrrT0aE7eJg,1138
+aiosatisfactory/https/api.py,sha256=FicCECnrCboN_8wUs9fAfuAZXD07nLGEhDfdg-lSvGo,11286
+aiosatisfactory/https/models.py,sha256=_NqEvyoRHlRFZ7PxYniHEPBfvd14pKTDzEf4eGya3z4,2324
+aiosatisfactory/lightweight/__init__.py,sha256=JT0Ege89Jc3fMLTerHa6Uf46XD-mZUI6-gB7TqnMOFA,1145
+aiosatisfactory/lightweight/const.py,sha256=N6215_KBw6KzSL-Gx1_wVwZqN67SnZWRd3t-Qi9jGyU,2259
+aiosatisfactory/lightweight/request.py,sha256=0qRyGY1E2vmmbQDA22_ECwUOUtC67H37m4JZaqYCb8I,1131
+aiosatisfactory/lightweight/response.py,sha256=_KfiGmChv2aUGAR5g3TC4DyVZF7p11vwA86aqgk9mm0,3316
+aiosatisfactory/lightweight/udp.py,sha256=QKodLyX7spC9497d8AOQ2uyLBWLIwAesjET_wk9QKT0,639
+aiosatisfactory-0.1.0.dist-info/licenses/LICENSE,sha256=n0Ob9a17RbQdD9wWCWxcoCa4Ue3oQ9q7wx2vA0L8ZnA,1062
+aiosatisfactory-0.1.0.dist-info/METADATA,sha256=0d3t8O2890YKq8r5keDepPPrtKHih2dkTeZcf1caQu8,2021
+aiosatisfactory-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiosatisfactory-0.1.0.dist-info/top_level.txt,sha256=t4_yQXShVWTN_tfB33k_hLZ63HudgMMy5jxuZjKnS9U,16
+aiosatisfactory-0.1.0.dist-info/RECORD,,

aiosatisfactory-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

aiosatisfactory-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rikys
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aiosatisfactory-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+aiosatisfactory