PyPI - albibong - Versions diffs - 1.0.0__py3-none-any.whl - Mend

albibong 1.0.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (46) hide show

albibong/__init__.py +82 -0
albibong/classes/__init__.py +0 -0
albibong/classes/character.py +83 -0
albibong/classes/coords.py +9 -0
albibong/classes/dungeon.py +59 -0
albibong/classes/item.py +41 -0
albibong/classes/location.py +48 -0
albibong/classes/logger.py +122 -0
albibong/classes/packet_handler.py +61 -0
albibong/classes/world_data.py +327 -0
albibong/gui_dist/No Equipment.png +0 -0
albibong/gui_dist/assets/index-BFSx0nua.css +1 -0
albibong/gui_dist/assets/index-DAndaN_4.js +161 -0
albibong/gui_dist/fame.png +0 -0
albibong/gui_dist/index.html +14 -0
albibong/gui_dist/re_spec.png +0 -0
albibong/gui_dist/silver.png +0 -0
albibong/gui_dist/vite.svg +1 -0
albibong/photon_packet_parser/__init__.py +4 -0
albibong/photon_packet_parser/command_type.py +7 -0
albibong/photon_packet_parser/crc_calculator.py +16 -0
albibong/photon_packet_parser/event_data.py +4 -0
albibong/photon_packet_parser/message_type.py +6 -0
albibong/photon_packet_parser/number_serializer.py +22 -0
albibong/photon_packet_parser/operation_request.py +4 -0
albibong/photon_packet_parser/operation_response.py +6 -0
albibong/photon_packet_parser/photon_packet_parser.py +168 -0
albibong/photon_packet_parser/protocol16_deserializer.py +302 -0
albibong/photon_packet_parser/protocol16_type.py +23 -0
albibong/photon_packet_parser/segmented_packet.py +5 -0
albibong/resources/EventCode.py +579 -0
albibong/resources/OperationCode.py +499 -0
albibong/resources/event_code.json +577 -0
albibong/resources/items.json +54035 -0
albibong/resources/maps.json +3565 -0
albibong/resources/operation_code.json +497 -0
albibong/threads/__init__.py +0 -0
albibong/threads/http_server.py +60 -0
albibong/threads/packet_handler_thread.py +32 -0
albibong/threads/sniffer_thread.py +27 -0
albibong/threads/websocket_server.py +168 -0
albibong-1.0.0.dist-info/METADATA +15 -0
albibong-1.0.0.dist-info/RECORD +46 -0
albibong-1.0.0.dist-info/WHEEL +4 -0
albibong-1.0.0.dist-info/entry_points.txt +2 -0
albibong-1.0.0.dist-info/licenses/LICENSE +19 -0

albibong/gui_dist/fame.png ADDED Viewed

Binary file

albibong/gui_dist/index.html ADDED Viewed

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + React + TS</title>
+    <script type="module" crossorigin src="/assets/index-DAndaN_4.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BFSx0nua.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

albibong/gui_dist/re_spec.png ADDED Viewed

Binary file

albibong/gui_dist/silver.png ADDED Viewed

Binary file

albibong/gui_dist/vite.svg ADDED Viewed

@@ -0,0 +1 @@

+ <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>

albibong/photon_packet_parser/__init__.py ADDED Viewed

@@ -0,0 +1,4 @@
+from albibong.photon_packet_parser.photon_packet_parser import PhotonPacketParser
+from albibong.photon_packet_parser.event_data import EventData
+from albibong.photon_packet_parser.operation_request import OperationRequest
+from albibong.photon_packet_parser.operation_response import OperationResponse

albibong/photon_packet_parser/command_type.py ADDED Viewed

@@ -0,0 +1,7 @@
+from enum import Enum
+class CommandType(Enum):
+    Disconnect = 4
+    SendReliable = 6
+    SendUnreliable = 7
+    SendFragment = 8

albibong/photon_packet_parser/crc_calculator.py ADDED Viewed

@@ -0,0 +1,16 @@
+class CrcCalculator:
+    @staticmethod
+    def calculate(_bytes, length):
+        result = 4294967295
+        key = 3988292384
+        for i in range(length):
+            result ^= _bytes[i]
+            for _ in range(8):
+                if (result & 1) > 0:
+                    result = result >> 1 ^ key
+                else:
+                    result >>= 1
+        return result

albibong/photon_packet_parser/event_data.py ADDED Viewed

@@ -0,0 +1,4 @@
+class EventData:
+    def __init__(self, code, parameters):
+        self.code = code
+        self.parameters = parameters

albibong/photon_packet_parser/message_type.py ADDED Viewed

@@ -0,0 +1,6 @@
+from enum import Enum
+class MessageType(Enum):
+    OperationRequest = 2
+    OperationResponse = 3
+    Event = 4

albibong/photon_packet_parser/number_serializer.py ADDED Viewed

@@ -0,0 +1,22 @@
+import io
+import struct
+class NumberSerializer:
+    @staticmethod
+    def deserialize_int(source: io.BytesIO):
+        buffer = source.read(4)
+        return struct.unpack(">i", buffer)[0]
+    @staticmethod
+    def deserialize_short(source: io.BytesIO):
+        buffer = source.read(2)
+        return struct.unpack(">h", buffer)[0]
+    @staticmethod
+    def serialize_int(value, target: io.BytesIO):
+        target.write(value >> 24)
+        target.write(value >> 16)
+        target.write(value >> 8)
+        target.write(value)
+        return target

albibong/photon_packet_parser/operation_request.py ADDED Viewed

@@ -0,0 +1,4 @@
+class OperationRequest:
+    def __init__(self, operation_code, parameters):
+        self.operation_code = operation_code
+        self.parameters = parameters

albibong/photon_packet_parser/operation_response.py ADDED Viewed

@@ -0,0 +1,6 @@
+class OperationResponse:
+    def __init__(self, operation_code, return_code, debug_message, parameters):
+        self.operation_code = operation_code
+        self.return_code = return_code
+        self.debug_message = debug_message
+        self.parameters = parameters

albibong/photon_packet_parser/photon_packet_parser.py ADDED Viewed

@@ -0,0 +1,168 @@
+import io
+from albibong.photon_packet_parser.message_type import MessageType
+from albibong.photon_packet_parser.command_type import CommandType
+from albibong.photon_packet_parser.segmented_packet import SegmentedPacket
+from albibong.photon_packet_parser.protocol16_deserializer import Protocol16Deserializer
+from albibong.photon_packet_parser.crc_calculator import CrcCalculator
+from albibong.photon_packet_parser.number_serializer import NumberSerializer
+COMMAND_HEADER_LENGTH = 12
+PHOTON_HEADER_LENGTH = 12
+class PhotonPacketParser:
+    def __init__(self, on_event, on_request, on_response):
+        self._pending_segments = {}
+        self.on_event = on_event
+        self.on_request = on_request
+        self.on_response = on_response
+    # MITIGATOR Challenge Response Packet
+    def is_mcr_packet(self, payload):
+        signatures = {
+            b"\x4d\x43\x52\x48\x33\x31\x31\x30",
+            b"\xe9\x71\x2d\xd5\x00\x01\x00\x00",
+            b"\xe9\x71\x2d\xd5\x01\x01\x00\x00",
+            b"\xe9\x71\x2d\xd5\x11\x01\x00\x00",
+        }
+        return payload[:8] in signatures
+    def handle_payload(self, payload):
+        if self.is_mcr_packet(payload):
+            return
+        payload = io.BytesIO(payload)
+        if payload.getbuffer().nbytes < PHOTON_HEADER_LENGTH:
+            return
+        peer_id = NumberSerializer.deserialize_short(payload)
+        flags = payload.read(1)[0]
+        command_count = payload.read(1)[0]
+        timestamp = NumberSerializer.deserialize_int(payload)
+        challenge = NumberSerializer.deserialize_int(payload)
+        is_encrypted = flags == 1
+        is_crc_enabled = flags == 0xCC
+        if is_encrypted:
+            return
+        if is_crc_enabled:
+            offset = payload.tell()
+            payload.seek(0)
+            crc = NumberSerializer.deserialize_int(payload)
+            payload.seek(offset)
+            payload = NumberSerializer.serialize_int(0, payload)
+            if crc != CrcCalculator.calculate(payload, payload.getbuffer().nbytes):
+                return
+        for _ in range(command_count):
+            self.handle_command(payload)
+    def handle_command(self, source: io.BytesIO):
+        command_type = source.read(1)[0]
+        channel_id = source.read(1)[0]
+        command_flags = source.read(1)[0]
+        # Skip 1 byte
+        source.read(1)
+        command_length = NumberSerializer.deserialize_int(source)
+        sequence_number = NumberSerializer.deserialize_int(source)
+        command_length -= COMMAND_HEADER_LENGTH
+        if command_type == CommandType.Disconnect.value:
+            return
+        elif command_type == CommandType.SendUnreliable.value:
+            source.read(4)
+            command_length -= 4
+            self.handle_send_reliable(source, command_length)
+        elif command_type == CommandType.SendReliable.value:
+            self.handle_send_reliable(source, command_length)
+        elif command_type == CommandType.SendFragment.value:
+            self.handle_send_fragment(source, command_length)
+        else:
+            source.read(command_length)
+    def handle_send_reliable(self, source: io.BytesIO, command_length: int):
+        # Skip 1 byte
+        source.read(1)
+        command_length -= 1
+        message_type = source.read(1)[0]
+        command_length -= 1
+        operation_length = command_length
+        payload = io.BytesIO(source.read(operation_length))
+        if message_type == MessageType.OperationRequest.value:
+            request_data = Protocol16Deserializer.deserialize_operation_request(payload)
+            self.on_request(request_data)
+        elif message_type == MessageType.OperationResponse.value:
+            response_data = Protocol16Deserializer.deserialize_operation_response(
+                payload
+            )
+            self.on_response(response_data)
+        elif message_type == MessageType.Event.value:
+            event_data = Protocol16Deserializer.deserialize_event_data(payload)
+            self.on_event(event_data)
+        # else:
+        #     print("Unknown message type: ", message_type)
+    def handle_send_fragment(self, source: io.BytesIO, command_length: int):
+        start_sequence_number = NumberSerializer.deserialize_int(source)
+        command_length -= 4
+        fragment_count = NumberSerializer.deserialize_int(source)
+        command_length -= 4
+        fragment_number = NumberSerializer.deserialize_int(source)
+        command_length -= 4
+        total_length = NumberSerializer.deserialize_int(source)
+        command_length -= 4
+        fragment_offset = NumberSerializer.deserialize_int(source)
+        command_length -= 4
+        fragment_length = command_length
+        self.handle_segmented_payload(
+            start_sequence_number,
+            total_length,
+            fragment_length,
+            fragment_offset,
+            source,
+        )
+    def handle_finished_segmented_packet(self, total_payload: bytearray):
+        command_length = len(total_payload)
+        self.handle_send_reliable(io.BytesIO(total_payload), command_length)
+    def handle_segmented_payload(
+        self,
+        start_sequence_number,
+        total_length,
+        fragment_length,
+        fragment_offset,
+        source,
+    ):
+        segmented_packet = self.get_segmented_packet(
+            start_sequence_number, total_length
+        )
+        for i in range(fragment_length):
+            segmented_packet.total_payload[fragment_offset + i] = source.read(1)[0]
+        segmented_packet.bytes_written += fragment_length
+        if segmented_packet.bytes_written >= segmented_packet.total_length:
+            self._pending_segments.pop(start_sequence_number)
+            self.handle_finished_segmented_packet(segmented_packet.total_payload)
+    def get_segmented_packet(self, start_sequence_number, total_length):
+        if start_sequence_number in self._pending_segments:
+            return self._pending_segments[start_sequence_number]
+        segmented_packet = SegmentedPacket(
+            total_length=total_length, total_payload=bytearray(total_length)
+        )
+        self._pending_segments[start_sequence_number] = segmented_packet
+        return segmented_packet

albibong/photon_packet_parser/protocol16_deserializer.py ADDED Viewed

@@ -0,0 +1,302 @@
+import io
+import struct
+import sys
+from albibong.photon_packet_parser.protocol16_type import Protocol16Type
+from albibong.photon_packet_parser.operation_request import OperationRequest
+from albibong.photon_packet_parser.operation_response import OperationResponse
+from albibong.photon_packet_parser.event_data import EventData
+class Protocol16Deserializer:
+    @staticmethod
+    def deserialize(input: io.BytesIO, type_code: int):
+        if (
+            type_code == Protocol16Type.UNKNOWN.value
+            or type_code == Protocol16Type.NULL.value
+        ):
+            return None
+        elif type_code == Protocol16Type.DICTIONARY.value:
+            return Protocol16Deserializer.deserialize_dictionary(input)
+        elif type_code == Protocol16Type.STRINGARRAY.value:
+            return Protocol16Deserializer.deserialize_string_array(input)
+        elif type_code == Protocol16Type.BYTE.value:
+            return Protocol16Deserializer.deserialize_byte(input)
+        elif type_code == Protocol16Type.DOUBLE.value:
+            return Protocol16Deserializer.deserialize_double(input)
+        elif type_code == Protocol16Type.EVENTDATA.value:
+            return Protocol16Deserializer.deserialize_event_data(input)
+        elif type_code == Protocol16Type.FLOAT.value:
+            return Protocol16Deserializer.deserialize_float(input)
+        elif type_code == Protocol16Type.INTEGER.value:
+            return Protocol16Deserializer.deserialize_integer(input)
+        elif type_code == Protocol16Type.HASHTABLE.value:
+            return Protocol16Deserializer.deserialize_hash_table(input)
+        elif type_code == Protocol16Type.SHORT.value:
+            return Protocol16Deserializer.deserialize_short(input)
+        elif type_code == Protocol16Type.LONG.value:
+            return Protocol16Deserializer.deserialize_long(input)
+        elif type_code == Protocol16Type.INTEGERARRAY.value:
+            return Protocol16Deserializer.deserialize_integer_array(input)
+        elif type_code == Protocol16Type.BOOLEAN.value:
+            return Protocol16Deserializer.deserialize_boolean(input)
+        elif type_code == Protocol16Type.OPERATIONRESPONSE.value:
+            return Protocol16Deserializer.deserialize_operation_response(input)
+        elif type_code == Protocol16Type.OPERATIONREQUEST.value:
+            return Protocol16Deserializer.deserialize_operation_request(input)
+        elif type_code == Protocol16Type.STRING.value:
+            return Protocol16Deserializer.deserialize_string(input)
+        elif type_code == Protocol16Type.BYTEARRAY.value:
+            return Protocol16Deserializer.deserialize_byte_array(input)
+        elif type_code == Protocol16Type.ARRAY.value:
+            return Protocol16Deserializer.deserialize_array(input)
+        elif type_code == Protocol16Type.OBJECTARRAY.value:
+            return Protocol16Deserializer.deserialize_object_array(input)
+        else:
+            raise Exception("Unknown type code: " + str(type_code))
+    @staticmethod
+    def deserialize_operation_request(input: io.BytesIO):
+        code = Protocol16Deserializer.deserialize_byte(input)
+        table = Protocol16Deserializer.deserialize_parameter_table(input)
+        return OperationRequest(code, table)
+    @staticmethod
+    def deserialize_operation_response(input: io.BytesIO):
+        code = Protocol16Deserializer.deserialize_byte(input)
+        return_code = Protocol16Deserializer.deserialize_short(input)
+        debug_message = Protocol16Deserializer.deserialize(
+            input, Protocol16Deserializer.deserialize_byte(input)
+        )
+        parameters = Protocol16Deserializer.deserialize_parameter_table(input)
+        return OperationResponse(code, return_code, debug_message, parameters)
+    @staticmethod
+    def deserialize_event_data(input: io.BytesIO):
+        code = Protocol16Deserializer.deserialize_byte(input)
+        parameters = Protocol16Deserializer.deserialize_parameter_table(input)
+        return EventData(code, parameters)
+    @staticmethod
+    def deserialize_parameter_table(input):
+        dictionary_size = Protocol16Deserializer.deserialize_short(input)
+        dictionary = {}
+        for _ in range(dictionary_size):
+            key = Protocol16Deserializer.deserialize_byte(input)
+            value_type_code = Protocol16Deserializer.deserialize_byte(input)
+            value = Protocol16Deserializer.deserialize(input, value_type_code)
+            dictionary[key] = value
+        return dictionary
+    @staticmethod
+    def deserialize_short(input: io.BytesIO):
+        buffer = input.read(2)
+        return struct.unpack(">h", buffer)[0]
+    @staticmethod
+    def deserialize_byte(input: io.BytesIO):
+        return input.read(1)[0]
+    @staticmethod
+    def deserialize_boolean(input: io.BytesIO):
+        return input.read(1)[0] != 0
+    @staticmethod
+    def deserialize_integer(input: io.BytesIO):
+        buffer = input.read(4)
+        return struct.unpack(">i", buffer)[0]
+    @staticmethod
+    def deserialize_long(input: io.BytesIO):
+        buffer = input.read(8)
+        if sys.byteorder == "little":
+            return struct.unpack(">q", buffer)[0]
+        return struct.unpack("<q", buffer)[0]
+    @staticmethod
+    def deserialize_float(input: io.BytesIO):
+        buffer = input.read(4)
+        if sys.byteorder == "little":
+            return struct.unpack(">f", buffer)[0]
+        return struct.unpack("<f", buffer)[0]
+    @staticmethod
+    def deserialize_double(input: io.BytesIO):
+        buffer = input.read(8)
+        if sys.byteorder == "little":
+            return struct.unpack(">d", buffer)[0]
+        return struct.unpack("<d", buffer)[0]
+    @staticmethod
+    def deserialize_string(input: io.BytesIO):
+        string_size = Protocol16Deserializer.deserialize_short(input)
+        if string_size == 0:
+            return ""
+        buffer = input.read(string_size)
+        return buffer.decode("utf-8")
+    @staticmethod
+    def deserialize_byte_array(input: io.BytesIO):
+        array_size = Protocol16Deserializer.deserialize_integer(input)
+        array = []
+        for _ in range(array_size):
+            tmp = Protocol16Deserializer.deserialize_byte(input)
+            array.append(tmp)
+        return array
+    @staticmethod
+    def deserialize_integer_array(input: io.BytesIO):
+        array_size = Protocol16Deserializer.deserialize_integer(input)
+        array = []
+        for _ in range(array_size):
+            tmp = Protocol16Deserializer.deserialize_integer(input)
+            array.append(tmp)
+        return array
+    @staticmethod
+    def deserialize_string_array(input: io.BytesIO):
+        array_size = Protocol16Deserializer.deserialize_short(input)
+        array = []
+        for _ in range(array_size):
+            tmp = Protocol16Deserializer.deserialize_string(input)
+            array.append(tmp)
+        return array
+    @staticmethod
+    def deserialize_object_array(input: io.BytesIO):
+        array_size = Protocol16Deserializer.deserialize_short(input)
+        array = []
+        for _ in range(array_size):
+            typeCode = Protocol16Deserializer.deserialize_byte(input)
+            tmp = Protocol16Deserializer.deserialize(input, typeCode)
+            array.append(tmp)
+        return array
+    @staticmethod
+    def deserialize_array(input: io.BytesIO):
+        array_size = Protocol16Deserializer.deserialize_short(input)
+        type_code = Protocol16Deserializer.deserialize_byte(input)
+        if type_code == Protocol16Type.ARRAY.value:
+            result = []
+            for _ in range(0, array_size):
+                tmp = Protocol16Deserializer.deserialize_array(input)
+                result.append(tmp)
+            return result
+        elif type_code == Protocol16Type.BYTEARRAY.value:
+            result = []
+            for _ in range(array_size):
+                tmp = Protocol16Deserializer.deserialize_byte_array(input)
+                result.append(tmp)
+            return result
+        elif type_code == Protocol16Type.DICTIONARY.value:
+            return Protocol16Deserializer.deserialize_dictionary_array(
+                input, array_size
+            )
+        else:
+            result = []
+            for _ in range(array_size):
+                tmp = Protocol16Deserializer.deserialize(input, type_code)
+                result.append(tmp)
+            return result
+    @staticmethod
+    def deserialize_dictionary(input: io.BytesIO):
+        key_type_code = Protocol16Deserializer.deserialize_byte(input)
+        value_type_code = Protocol16Deserializer.deserialize_byte(input)
+        dictionary_size = Protocol16Deserializer.deserialize_short(input)
+        return Protocol16Deserializer.deserialize_dictionary_elements(
+            input, dictionary_size, key_type_code, value_type_code
+        )
+    @staticmethod
+    def deserialize_dictionary_elements(
+        input: io.BytesIO,
+        dictionary_size: int,
+        key_type_code: int,
+        value_type_code: int,
+    ):
+        output = {}
+        for _ in range(dictionary_size):
+            key = Protocol16Deserializer.deserialize(
+                input,
+                (
+                    Protocol16Deserializer.deserialize_byte(input)
+                    if key_type_code == 0 or key_type_code == 42
+                    else key_type_code
+                ),
+            )
+            value = Protocol16Deserializer.deserialize(
+                input,
+                (
+                    Protocol16Deserializer.deserialize_byte(input)
+                    if value_type_code == 0 or value_type_code == 42
+                    else value_type_code
+                ),
+            )
+            output[key] = value
+        return output
+    @staticmethod
+    def deserialize_dictionary_array(input: io.BytesIO, size: int):
+        key_type_code = Protocol16Deserializer.deserialize_byte(input)
+        value_type_code = Protocol16Deserializer.deserialize_byte(input)
+        output = []
+        for _ in range(size):
+            dictionary_size = Protocol16Deserializer.deserialize_short(input)
+            dictionary = {}
+            for _ in range(dictionary_size):
+                key = None
+                if key_type_code > 0:
+                    key = Protocol16Deserializer.deserialize(input, key_type_code)
+                else:
+                    next_key_type_code = Protocol16Deserializer.deserialize_byte(input)
+                    key = Protocol16Deserializer.deserialize(input, next_key_type_code)
+                value = None
+                if value_type_code > 0:
+                    value = Protocol16Deserializer.deserialize(input, value_type_code)
+                else:
+                    next_value_type_code = Protocol16Deserializer.deserialize_byte(
+                        input
+                    )
+                    value = Protocol16Deserializer.deserialize(
+                        input, next_value_type_code
+                    )
+                dictionary[key] = value
+            output.append(dictionary)
+        return output
+    @staticmethod
+    def deserialize_hash_table(input: io.BytesIO):
+        size = Protocol16Deserializer.deserialize_short(input)
+        return Protocol16Deserializer.deserialize_dictionary_elements(
+            input, size, Protocol16Type.UNKNOWN, Protocol16Type.UNKNOWN
+        )

albibong/photon_packet_parser/protocol16_type.py ADDED Viewed

@@ -0,0 +1,23 @@
+from enum import Enum
+class Protocol16Type(Enum):
+    UNKNOWN = 0
+    NULL = 42
+    DICTIONARY = 68
+    STRINGARRAY = 97
+    BYTE = 98
+    DOUBLE = 100
+    EVENTDATA = 101
+    FLOAT = 102
+    INTEGER = 105
+    HASHTABLE = 104
+    SHORT = 107
+    LONG = 108
+    INTEGERARRAY = 110
+    BOOLEAN = 111
+    OPERATIONRESPONSE = 112
+    OPERATIONREQUEST = 113
+    STRING = 115
+    BYTEARRAY = 120
+    ARRAY = 121
+    OBJECTARRAY = 122

albibong/photon_packet_parser/segmented_packet.py ADDED Viewed

@@ -0,0 +1,5 @@
+class SegmentedPacket:
+    def __init__(self, total_length=0, bytes_written=0, total_payload=bytearray(0)):
+        self.total_length = total_length
+        self.bytes_written = bytes_written
+        self.total_payload = total_payload