pypinch 0.0.1__tar.gz

pypinch-0.0.1/LICENSE

@@ -0,0 +1,17 @@
+MIT License
+Copyright (c) 2026 Aharon Sambol
+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.

pypinch-0.0.1/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: pypinch
+Version: 0.0.1
+Summary: Schemaless binary serialization format without limitations
+Author-email: Aharon Sambol <aharon.sambol@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/AharonSambol/pypinch
+Project-URL: Issues, https://github.com/AharonSambol/pypinch/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Utilities
+Classifier: Topic :: File Formats
+Classifier: Typing :: Typed
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file

pypinch-0.0.1/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pypinch"
+version = "0.0.1"
+authors = [
+    { name="Aharon Sambol", email="aharon.sambol@gmail.com" },
+]
+description = "Schemaless binary serialization format without limitations"
+readme = "README.md"
+requires-python = ">=3.8"
+dynamic = ["dependencies"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Topic :: Utilities",
+    "Topic :: File Formats",
+    "Typing :: Typed",
+    "Intended Audience :: Developers",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+Homepage = "https://github.com/AharonSambol/pypinch"
+Issues = "https://github.com/AharonSambol/pypinch/issues"
+
+[tool.setuptools.dynamic]
+dependencies = {file = ["requirements.txt"]}

pypinch-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pypinch-0.0.1/src/pinch_python/__init__.py

@@ -0,0 +1,5 @@
+from .serialize.serialize import dump_bytes
+from .deserialize.deserialize import load_bytes
+
+pinch = dump_bytes
+unpinch = load_bytes

pypinch-0.0.1/src/pinch_python/deserialize/deserialize.py

@@ -0,0 +1,301 @@
+import gc
+import math
+import struct
+import typing
+from typing import Tuple, Optional, List
+
+from consts import NUMBER_BASE, ObjType, POSITIVE_INT_FLAG, FALSE_FLAG, TRUE_FLAG, NULL_FLAG, BYTES_FLAG, \
+    LIST_FLAG, \
+    DICT_FLAG, STR_KEY_DICT_FLAG, FLOAT_FLAG, STR_FLAG, NEGATIVE_INT_FLAG, EMPTY_STR_FLAG, EMPTY_BYTES_FLAG, \
+    EMPTY_LIST_FLAG, EMPTY_DICT_FLAG, CONSISTENT_TYPE_LIST_FLAG, INT_FLAG, BOOL_FLAG, POINTER_FLAG, \
+    ByteLike, HEADER, CONSISTENT_TYPE_DICT_FLAG, REVERSE_SMALL_INTS, BIG_ENDIAN_DOUBLE_FORMAT, NUMBER_OF_BITS_IN_BYTE, \
+    LEFTMOST_BIT_MASK, BYTES_IN_DOUBLE, NEGATIVE_NUMBER_SIGN
+
+
+from exceptions import DecodingError
+from src.pinch_python.deserialize.settings import Settings
+from src.pinch_python.deserialize.utils import decode_number
+
+
+
+def load_bytes(
+    buffer: ByteLike,
+    *,
+    modify_input: bool = False,
+    encoding: Optional[str] = None,
+    use_tuples: bool = False,
+    use_pointers: bool = True,
+    stop_gc: bool = False,
+) -> ObjType:
+    try:
+        if stop_gc:
+            gc.freeze()
+
+        settings = Settings(
+            encoding=encoding,
+            use_tuples=use_tuples,  # TODO
+            use_pointers=use_pointers,
+            pointers={} if use_pointers else None
+        )
+        if modify_input and type(buffer) is bytearray:
+            original_buffer_len = len(buffer)
+            del buffer[:len(HEADER)]
+            return deserialize_object_from_bytearray(buffer, original_buffer_len, settings)
+        else:
+            return deserialize_object(buffer, len(HEADER), settings)[0]
+    finally:
+        if stop_gc:
+            gc.unfreeze()
+
+
+def deserialize_object_from_bytearray(buffer: bytearray, original_buffer_len: int, settings: Settings) -> ObjType:
+    flag = buffer[0]
+    del buffer[0]
+    if flag == POSITIVE_INT_FLAG:
+        num, end = decode_number(buffer, 0)
+        del buffer[:end]
+        return num
+    elif flag == NEGATIVE_INT_FLAG:
+        num, end = decode_number(buffer, 0)
+        del buffer[:end]
+        return -num
+    elif flag == FLOAT_FLAG:
+        num = struct.unpack(BIG_ENDIAN_DOUBLE_FORMAT, buffer[:BYTES_IN_DOUBLE])[0]
+        del buffer[:BYTES_IN_DOUBLE]
+        return num
+    elif flag == STR_FLAG:
+        return deserialize_str_from_bytearray(buffer, original_buffer_len, settings)
+    elif flag == EMPTY_STR_FLAG:
+        return ""
+    elif flag == BYTES_FLAG:
+        length, pointer = decode_number(buffer, 0)
+        byts = buffer[pointer:pointer + length]
+        del buffer[:pointer + length]
+        return bytes(byts)
+    elif flag == EMPTY_BYTES_FLAG:
+        return b""
+    elif flag == TRUE_FLAG:
+        return True
+    elif flag == FALSE_FLAG:
+        return False
+    elif flag == NULL_FLAG:
+        return None
+    elif flag == LIST_FLAG:
+        length, pointer = decode_number(buffer, 0)
+        del buffer[:pointer]
+        if settings.use_tuples:
+            return tuple(deserialize_object_from_bytearray(buffer, original_buffer_len, settings) for _ in range(length))
+        return [deserialize_object_from_bytearray(buffer, original_buffer_len, settings) for _ in range(length)]
+    elif flag == EMPTY_LIST_FLAG:
+        return tuple() if settings.use_tuples else []
+    elif flag == CONSISTENT_TYPE_LIST_FLAG:
+        typ_flag = buffer[0]
+        length, pointer = decode_number(buffer, 1)
+        del buffer[:pointer]
+        if typ_flag == NULL_FLAG:
+            return ((None,) if settings.use_tuples else [None]) * length
+        elif typ_flag == INT_FLAG:
+            def extract_number(_buffer: bytearray) -> int:
+                if _buffer[0] == NEGATIVE_NUMBER_SIGN:
+                    _num, _pointer = decode_number(_buffer, 1, base=NUMBER_BASE - 1)
+                    del _buffer[:_pointer]
+                    return -_num
+                else:
+                    _num, _pointer = decode_number(_buffer, 0, base=NUMBER_BASE - 1)
+                    del _buffer[:_pointer]
+                    return _num
+            if settings.use_tuples:
+                return tuple(extract_number(buffer) for _ in range(length))
+            return [extract_number(buffer) for _ in range(length)]
+        elif typ_flag == BOOL_FLAG:
+            res_list = typing.cast(List[bool], [None] * length)
+            length_in_bytes = math.ceil(length / NUMBER_OF_BITS_IN_BYTE)
+            try:
+                for i, byte in enumerate(buffer[:length_in_bytes]):
+                    for j in range(NUMBER_OF_BITS_IN_BYTE):
+                        res_list[i * NUMBER_OF_BITS_IN_BYTE + j] = (byte & LEFTMOST_BIT_MASK) == LEFTMOST_BIT_MASK
+                        byte <<= 1
+            except IndexError:
+                pass
+            return res_list
+        elif typ_flag == BYTES_FLAG:
+            res_list = typing.cast(List[bytes], [None] * length)
+            for i in range(length):
+                length, pointer = decode_number(buffer, 0)
+                res_list[i] = bytes(buffer[pointer:pointer + length])
+                del buffer[:pointer + length]
+            return res_list
+        elif typ_flag == STR_FLAG:
+            if settings.use_tuples:
+                return tuple(deserialize_str_from_bytearray(buffer, original_buffer_len, settings) for _ in range(length))
+            return [deserialize_str_from_bytearray(buffer, original_buffer_len, settings) for _ in range(length)]
+        elif typ_flag == FLOAT_FLAG:
+            res_list = typing.cast(List[float], [None] * length)
+            for i in range(length):
+                res_list[i] = struct.unpack(BIG_ENDIAN_DOUBLE_FORMAT, buffer[:BYTES_IN_DOUBLE])[0]
+                del buffer[:BYTES_IN_DOUBLE]
+            return res_list
+        else:
+            raise DecodingError(f"Unexpected type flag: {typ_flag}")
+    elif flag == DICT_FLAG:
+        length, pointer = decode_number(buffer, 0)
+        del buffer[:pointer]
+        return {
+            deserialize_object_from_bytearray(buffer, original_buffer_len, settings): deserialize_object_from_bytearray(buffer, original_buffer_len, settings)
+            for _ in range(length)
+        }
+    elif flag == EMPTY_DICT_FLAG:
+        return {}
+    elif flag == STR_KEY_DICT_FLAG:
+        length, pointer = decode_number(buffer, 0)
+        del buffer[:pointer]
+        return {
+            deserialize_str_from_bytearray(buffer, original_buffer_len, settings): deserialize_object_from_bytearray(buffer, original_buffer_len, settings)
+            for _ in range(length)
+        }
+    elif flag == CONSISTENT_TYPE_DICT_FLAG:
+        raise Exception("not implemented yet") 	# todo
+    elif flag == POINTER_FLAG:
+        position, pointer = decode_number(buffer, 0)
+        del buffer[:pointer]
+        return settings.pointers[position]
+    elif flag == BOOL_FLAG:
+        raise DecodingError("unexpected flag: BOOL")
+    elif flag == INT_FLAG:
+        raise DecodingError("unexpected flag: INT")
+    else:
+        return REVERSE_SMALL_INTS[flag]
+
+
+def deserialize_str_from_bytearray(buffer: bytearray, original_buffer_len: int, settings: Settings) -> str:
+    position = original_buffer_len - len(buffer)
+    length, pointer = decode_number(buffer, 0)
+    encoded_str = buffer[pointer:pointer + length]
+    del buffer[:pointer + length]
+    string = encoded_str.decode(encoding=settings.encoding) if settings.encoding else encoded_str.decode()
+    if settings.use_pointers:
+        settings.pointers[position] = string
+    return string
+
+
+def deserialize_object(buffer: bytes, pointer: int, settings: Settings) -> (ObjType, int):
+    flag = buffer[pointer]
+    pointer += 1
+    if flag == POSITIVE_INT_FLAG:
+        return decode_number(buffer, pointer)
+    elif flag == NEGATIVE_INT_FLAG:
+        num, pointer = decode_number(buffer, pointer)
+        return -num, pointer
+    elif flag == INT_FLAG:
+        raise DecodingError("unexpected flag")
+    elif flag == FLOAT_FLAG:
+        num = struct.unpack(BIG_ENDIAN_DOUBLE_FORMAT, buffer[pointer:pointer + BYTES_IN_DOUBLE])[0]
+        return num, pointer + BYTES_IN_DOUBLE
+    elif flag == STR_FLAG:
+        return deserialize_str(buffer, pointer, settings)
+    elif flag == EMPTY_STR_FLAG:
+        return "", pointer
+    elif flag == BYTES_FLAG:
+        length, pointer = decode_number(buffer, pointer)
+        return bytes(buffer[pointer:pointer + length]), pointer + length
+    elif flag == EMPTY_BYTES_FLAG:
+        return b"", pointer
+    elif flag == BOOL_FLAG:
+        raise DecodingError("unexpected flag")
+    elif flag == TRUE_FLAG:
+        return True, pointer
+    elif flag == FALSE_FLAG:
+        return False, pointer
+    elif flag == NULL_FLAG:
+        return None, pointer
+    elif flag == LIST_FLAG:
+        length, pointer = decode_number(buffer, pointer)
+        res_list = [None] * length
+        for i in range(length):
+            res_list[i], pointer = deserialize_object(buffer, pointer, settings)
+        return res_list, pointer
+    elif flag == EMPTY_LIST_FLAG:
+        return (tuple() if settings.use_tuples else []), pointer
+    elif flag == CONSISTENT_TYPE_LIST_FLAG:
+        typ_flag = buffer[pointer]
+        length, pointer = decode_number(buffer, pointer + 1)
+        if typ_flag == NULL_FLAG:
+            return ((None,) if settings.use_tuples else [None]) * length, pointer
+        elif typ_flag == INT_FLAG:
+            res_list = typing.cast(List[int], [None] * length)
+            for i in range(length):
+                if buffer[pointer] == NUMBER_BASE - 1:
+                    num, pointer = decode_number(buffer, pointer + 1, base=NUMBER_BASE - 1)
+                    res_list[i] = -num
+                else:
+                    num, pointer = decode_number(buffer, pointer, base=NUMBER_BASE - 1)
+                    res_list[i] = num
+            return res_list, pointer
+        elif typ_flag == BOOL_FLAG:
+            res_list = typing.cast(List[bool], [None] * length)
+            length_in_bytes = math.ceil(length / NUMBER_OF_BITS_IN_BYTE)
+            try:
+                for i in range(length_in_bytes):
+                    byte = buffer[pointer + i]
+                    for j in range(NUMBER_OF_BITS_IN_BYTE):
+                        res_list[i * NUMBER_OF_BITS_IN_BYTE + j] = (byte & LEFTMOST_BIT_MASK) == LEFTMOST_BIT_MASK
+                        byte <<= 1
+            except IndexError:
+                pass
+            return res_list, pointer + length_in_bytes
+        elif typ_flag == BYTES_FLAG:
+            res_list = typing.cast(List[bytes], [None] * length)
+            for i in range(length):
+                bytes_length, pointer = decode_number(buffer, pointer)
+                res_list[i] = bytes(buffer[pointer:pointer + bytes_length])
+                pointer += bytes_length
+            return res_list, pointer
+        elif typ_flag == STR_FLAG:
+            res_list = typing.cast(List[str], [None] * length)
+            for i in range(length):
+                res_list[i], pointer = deserialize_str(buffer, pointer, settings)
+            return res_list, pointer
+        elif typ_flag == FLOAT_FLAG:
+            res_list = typing.cast(List[float], [None] * length)
+            for i in range(length):
+                res_list[i] = struct.unpack(BIG_ENDIAN_DOUBLE_FORMAT, buffer[pointer:pointer + BYTES_IN_DOUBLE])[0]
+                pointer += BYTES_IN_DOUBLE
+            return res_list, pointer
+        else:
+            raise DecodingError(f"Unexpected type flag: {typ_flag}")
+    elif flag == DICT_FLAG:
+        length, pointer = decode_number(buffer, pointer)
+        res_dict = {}
+        for i in range(length):
+            k, pointer = deserialize_object(buffer, pointer, settings)
+            v, pointer = deserialize_object(buffer, pointer, settings)
+            res_dict[k] = v
+        return res_dict, pointer
+    elif flag == EMPTY_DICT_FLAG:
+        return {}, pointer
+    elif flag == STR_KEY_DICT_FLAG:
+        length, pointer = decode_number(buffer, pointer)
+        res_dict = {}
+        for i in range(length):
+            k, pointer = deserialize_str(buffer, pointer, settings)
+            v, pointer = deserialize_object(buffer, pointer, settings)
+            res_dict[k] = v
+        return res_dict, pointer
+
+    elif flag == CONSISTENT_TYPE_DICT_FLAG:
+        raise Exception("not implemented yet")  # todo
+    elif flag == POINTER_FLAG:
+        position, pointer = decode_number(buffer, pointer)
+        return settings.pointers[position], pointer
+    else:
+        return REVERSE_SMALL_INTS[flag], pointer
+
+
+def deserialize_str(buffer: bytes, pointer: int, settings: Settings) -> Tuple[str, int]:
+    start = pointer
+    length, pointer = decode_number(buffer, pointer)
+    encoded_str = buffer[pointer:pointer + length]
+    string = encoded_str.decode(encoding=settings.encoding) if settings.encoding else encoded_str.decode()
+    if settings.use_pointers:
+        settings.pointers[start] = string
+    return string, pointer + length

pypinch-0.0.1/src/pinch_python/deserialize/settings.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+from typing import Dict, Optional
+
+
+@dataclass
+class Settings:
+    encoding: Optional[str]
+    use_tuples: bool
+    use_pointers: bool
+    pointers: Dict

pypinch-0.0.1/src/pinch_python/deserialize/utils.py

@@ -0,0 +1,15 @@
+from typing import Tuple
+
+from consts import ByteLike, NUMBER_BASE, ENDING_FLAG
+
+
+def decode_number(num: ByteLike, pointer: int, base: int = NUMBER_BASE) -> Tuple[int, int]:
+    if num[pointer] != ENDING_FLAG:
+        return num[pointer], pointer + 1
+    power = res = 0
+    pointer += 1
+    while num[pointer] != ENDING_FLAG:
+        res += num[pointer] * base ** power
+        power += 1
+        pointer += 1
+    return res, pointer + 1

pypinch-0.0.1/src/pinch_python/serialize/serialize.py

@@ -0,0 +1,222 @@
+import struct
+from datetime import datetime
+from typing import Union, List, Tuple
+
+from consts import NUMBER_BASE, ObjType, POSITIVE_INT_FLAG, FALSE_FLAG, TRUE_FLAG, NULL_FLAG, BYTES_FLAG, \
+    LIST_FLAG, \
+    DICT_FLAG, STR_KEY_DICT_FLAG, FLOAT_FLAG, STR_FLAG, NEGATIVE_INT_FLAG, EMPTY_STR_FLAG, EMPTY_BYTES_FLAG, \
+    EMPTY_LIST_FLAG, EMPTY_DICT_FLAG, SMALL_INTS, CONSISTENT_TYPE_LIST_FLAG, INT_FLAG, BOOL_FLAG, POINTER_FLAG, HEADER, \
+    BIG_ENDIAN_DOUBLE_FORMAT, NUMBER_OF_BITS_IN_BYTE
+from exceptions import EncodingError
+from src.pinch_python.serialize.settings import Settings
+from src.pinch_python.serialize.utils import encode_number
+
+_pack_double = struct.Struct(BIG_ENDIAN_DOUBLE_FORMAT).pack
+
+
+def dump_bytes(obj: ObjType, *, allow_non_string_keys: bool = True, modify_input: bool = False, encoding: str = None,
+               use_pointers: bool = False, serialize_dates: bool = True) -> bytearray:
+    settings = Settings(
+        allow_non_string_keys=allow_non_string_keys,
+        modify_input=modify_input,  # TODO
+        encoding=encoding,
+        use_pointers=False,
+        pointers={} if use_pointers else None,
+        serialize_dates=serialize_dates,
+    )
+    buffer = bytearray(HEADER)
+    serialize_object_with_type(buffer, obj, settings)
+    return buffer
+
+
+def serialize_object_with_type(buffer: bytearray, obj: ObjType, settings: Settings) -> None:
+    typ = type(obj)
+    if typ is str:
+        encode_normally = True
+        if len(obj) == 0:
+            buffer.append(EMPTY_STR_FLAG)
+            encode_normally = False
+            # todo                          python 3.9
+        elif settings.use_pointers and (prev_pos := settings.pointers.get(obj)):
+            temp_buffer = bytearray()
+            temp_buffer.append(POINTER_FLAG)
+            encode_number(temp_buffer, prev_pos)
+            if len(temp_buffer) <= len(obj) + 1:
+                buffer.extend(temp_buffer)
+                encode_normally = False
+        if encode_normally:
+            buffer.append(STR_FLAG)
+            if settings.use_pointers:
+                settings.pointers[obj] = len(buffer)
+            encoded_str = obj.encode(encoding=settings.encoding) if settings.encoding else obj.encode()
+            encode_number(buffer, len(encoded_str))
+            buffer.extend(encoded_str)
+    elif typ is int:
+        if num_byte := SMALL_INTS.get(obj):
+            buffer.append(num_byte)
+        elif obj > 0:
+            buffer.append(POSITIVE_INT_FLAG)
+            encode_number(buffer, obj)
+        else:
+            buffer.append(NEGATIVE_INT_FLAG)
+            encode_number(buffer, -obj)
+    elif typ is bool:
+        buffer.append(TRUE_FLAG if obj else FALSE_FLAG)
+    elif obj is None:
+        buffer.append(NULL_FLAG)
+    elif typ is list or typ is tuple:
+        if len(obj) == 0:
+            buffer.append(EMPTY_LIST_FLAG)
+        elif is_consistent_type_list(obj, settings):
+            first_type = type(obj[0])
+            if first_type is str and settings.use_pointers:
+                serialize_normal_list(buffer, obj, settings)
+            elif obj[0] is None:
+                buffer.append(CONSISTENT_TYPE_LIST_FLAG)
+                buffer.append(NULL_FLAG)
+                encode_number(buffer, len(obj))
+            elif first_type is int:
+                # no longer have the flag to distinguish between positive and negative numbers so do this instead
+                buffer.append(CONSISTENT_TYPE_LIST_FLAG)
+                buffer.append(INT_FLAG)
+                encode_number(buffer, len(obj))
+                for item in obj:
+                    if item <= 0:
+                        buffer.append(NUMBER_BASE - 1)
+                        encode_number(buffer, -item, base=NUMBER_BASE - 1)
+                    else:
+                        encode_number(buffer, item, base=NUMBER_BASE - 1)
+            elif first_type is bool:
+                buffer.append(CONSISTENT_TYPE_LIST_FLAG)
+                buffer.append(BOOL_FLAG)
+                encode_number(buffer, len(obj))
+                byte = number_of_bits = 0
+                for item in obj:
+                    byte = (byte << 1) | item
+                    number_of_bits += 1
+                    if number_of_bits == NUMBER_OF_BITS_IN_BYTE:
+                        buffer.append(byte)
+                        byte = number_of_bits = 0
+                if number_of_bits:
+                    buffer.append(byte << (NUMBER_OF_BITS_IN_BYTE - number_of_bits))
+            else:
+                buffer.append(CONSISTENT_TYPE_LIST_FLAG)
+                try:
+                    buffer.append({str: STR_FLAG, bytes: BYTES_FLAG, float: FLOAT_FLAG, datetime: STR_FLAG}[first_type])
+                except KeyError:
+                    raise EncodingError(f"Unexpected type: {first_type}")
+
+                encode_number(buffer, len(obj))
+                for item in obj:
+                    serialize_object_without_type(buffer, item, settings)
+        else:
+            serialize_normal_list(buffer, obj, settings)
+    elif typ is dict:
+        if len(obj) == 0:
+            buffer.append(EMPTY_DICT_FLAG)
+        elif not settings.use_pointers and not settings.allow_non_string_keys:
+            buffer.append(STR_KEY_DICT_FLAG)
+            encode_number(buffer, len(obj))
+            for k, v in obj.items():
+                if type(k) is not str:
+                    raise EncodingError("Encountered a non string key while allow_non_string_keys is False")
+                serialize_object_without_type(buffer, k, settings)
+                serialize_object_with_type(buffer, v, settings)
+        elif not settings.use_pointers and all(type(x) is str for x in obj.keys()):
+            buffer.append(STR_KEY_DICT_FLAG)
+            encode_number(buffer, len(obj))
+            for k, v in obj.items():
+                serialize_object_without_type(buffer, k, settings)
+                serialize_object_with_type(buffer, v, settings)
+        else:
+            buffer.append(DICT_FLAG)
+            encode_number(buffer, len(obj))
+            for k, v in obj.items():
+                serialize_object_with_type(buffer, k, settings)
+                serialize_object_with_type(buffer, v, settings)
+    elif typ is float:
+        buffer.append(FLOAT_FLAG)
+        buffer.extend(_pack_double(obj))
+    elif typ is bytes:
+        if len(obj) == 0:
+            buffer.append(EMPTY_BYTES_FLAG)
+        else:
+            buffer.append(BYTES_FLAG)
+            encode_number(buffer, len(obj))
+            buffer.extend(obj)
+    elif typ is datetime and settings.serialize_dates:
+        return serialize_object_with_type(buffer, obj.isoformat(), settings)
+    else:
+        if typ is datetime and not settings.serialize_dates:
+            raise EncodingError(f"Unexpected type: datetime, with flag serialize_dates disabled")
+        raise EncodingError(f"Unexpected type: {typ}")
+
+
+def serialize_normal_list(buffer: bytearray, obj: Union[List, Tuple], settings: Settings) -> None:
+    buffer.append(LIST_FLAG)
+    encode_number(buffer, len(obj))
+    for item in obj:
+        serialize_object_with_type(buffer, item, settings)
+
+
+def is_consistent_type_list(obj: Union[List, Tuple], settings: Settings) -> bool:
+    if len(obj) <= 1:
+        return False
+    first_type = type(obj[0])
+    if first_type in [list, dict, tuple]:
+        return False
+    if first_type is str and settings.use_pointers:
+        return all(type(x) is str and x not in settings.pointers for x in obj)
+    return all(type(x) is first_type for x in obj)
+
+
+def serialize_object_without_type(buffer: bytearray, obj: ObjType, settings: Settings) -> None:
+    typ = type(obj)
+    if typ is int:
+        encode_number(buffer, obj if obj > 0 else -obj)
+    elif typ is bool:
+        buffer.append(TRUE_FLAG if obj else FALSE_FLAG)
+    elif obj is None:
+        buffer.append(NULL_FLAG)
+    elif typ is bytes:
+        encode_number(buffer, len(obj))
+        buffer.extend(obj)
+    elif typ is list or typ is tuple:
+        encode_number(buffer, len(obj))
+        for item in obj:
+            serialize_object_with_type(buffer, item, settings)
+    elif typ is dict:
+        if len(obj) == 0:
+            buffer.append(EMPTY_DICT_FLAG)
+        elif not settings.use_pointers and not settings.allow_non_string_keys:
+            buffer.append(STR_KEY_DICT_FLAG)
+            encode_number(buffer, len(obj))
+            for k, v in obj.items():
+                if type(k) is not str:
+                    raise EncodingError("Encountered a non string key while allow_non_string_keys is False")
+                serialize_object_without_type(buffer, k, settings)
+                serialize_object_with_type(buffer, v, settings)
+        elif not settings.use_pointers and all(type(x) is str for x in obj.keys()):
+            buffer.append(STR_KEY_DICT_FLAG)
+            encode_number(buffer, len(obj))
+            for k, v in obj.items():
+                serialize_object_without_type(buffer, k, settings)
+                serialize_object_with_type(buffer, v, settings)
+        else:
+            buffer.append(DICT_FLAG)
+            encode_number(buffer, len(obj))
+            for k, v in obj.items():
+                serialize_object_with_type(buffer, k, settings)
+                serialize_object_with_type(buffer, v, settings)
+    elif typ is float:
+        buffer.extend(_pack_double(obj))
+    elif typ is str:
+        encoded_str = obj.encode(encoding=settings.encoding) if settings.encoding else obj.encode()
+        if settings.use_pointers:
+            settings.pointers[obj] = len(buffer)
+        encode_number(buffer, len(encoded_str))
+        buffer.extend(encoded_str)
+    elif typ is datetime and settings.serialize_dates:
+        return serialize_object_without_type(buffer, obj.isoformat(), settings)
+    else:
+        raise EncodingError(f"Unexpected type: {typ}")

pypinch-0.0.1/src/pinch_python/serialize/settings.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass
+from typing import Dict
+
+
+@dataclass
+class Settings:
+    allow_non_string_keys: bool
+    modify_input: bool
+    encoding: str
+    use_pointers: bool
+    pointers: Dict
+    serialize_dates: bool

pypinch-0.0.1/src/pinch_python/serialize/utils.py

@@ -0,0 +1,12 @@
+from consts import NUMBER_BASE, ENDING_FLAG
+
+
+def encode_number(buffer: bytearray, num: int, base: int = NUMBER_BASE) -> None:
+    if num < base:
+        buffer.append(num)
+    else:
+        buffer.append(ENDING_FLAG)
+        while num:
+            num, remainder = divmod(num, base)
+            buffer.append(remainder)
+        buffer.append(ENDING_FLAG)

pypinch-0.0.1/src/pypinch.egg-info/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: pypinch
+Version: 0.0.1
+Summary: Schemaless binary serialization format without limitations
+Author-email: Aharon Sambol <aharon.sambol@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/AharonSambol/pypinch
+Project-URL: Issues, https://github.com/AharonSambol/pypinch/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Utilities
+Classifier: Topic :: File Formats
+Classifier: Typing :: Typed
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file

pypinch-0.0.1/src/pypinch.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+requirements.txt
+src/__init__.py
+src/pinch_python/__init__.py
+src/pinch_python/deserialize/__init__.py
+src/pinch_python/deserialize/deserialize.py
+src/pinch_python/deserialize/settings.py
+src/pinch_python/deserialize/utils.py
+src/pinch_python/serialize/__init__.py
+src/pinch_python/serialize/serialize.py
+src/pinch_python/serialize/settings.py
+src/pinch_python/serialize/utils.py
+src/pypinch.egg-info/PKG-INFO
+src/pypinch.egg-info/SOURCES.txt
+src/pypinch.egg-info/dependency_links.txt
+src/pypinch.egg-info/top_level.txt
+tests/test__serialize_deserialize.py

pypinch-0.0.1/src/pypinch.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pypinch-0.0.1/src/pypinch.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+__init__
+pinch_python

pypinch-0.0.1/tests/test__serialize_deserialize.py

@@ -0,0 +1,255 @@
+import copy
+import datetime
+import math
+import sys
+
+if sys.version_info.major == 3 and sys.version_info.minor < 9:
+    from backports.zoneinfo import ZoneInfo
+else:
+    from zoneinfo import ZoneInfo
+
+import pytest
+
+from src import pinch_python
+
+ALL_TYPES_OF_OBJECTS = [
+    (1231,),
+    (1,),
+    (332634,),
+    (5437890568343289547384,),
+    (0,),
+    (-1231,),
+    (-1,),
+    (-332634,),
+    (-5437890568343289547384,),
+
+    (1.000000000001,),
+    (100000000000000000000000000000000000000000.1,),
+    (23423523.543262346234,),
+    (4.4,),
+    (-1.000000000001,),
+    (-100000000000000000000000000000000000000000.1,),
+    (-23423523.543262346234,),
+    (-4.4,),
+
+    (math.inf,),
+    (-math.inf,),
+
+    ("afsag",),
+    pytest.param("092u384oiwjrklsgmfoisgjldkxfmoweij;lksgzwaoi;elgjskznwoi;jetlaksfdnv" * 1_000_000, id="long string"),
+    pytest.param("".join(chr(i) for i in range(10000)), id="lots of unicode"),
+    ("",),
+
+    (b"1234",),
+    (b"abcdefghijklmnopqrstuvwxyz",),
+    (b"",),
+    pytest.param(b"".join(bytes(i) for i in range(10000)), id="lots of bytes"),
+
+    (None,),
+    (True,),
+    (False,),
+
+    ([None] * 10,),
+    ([b"1234", b"asgsa", b"sgaeg4we"],),
+    ([0.1, 0.2, 0.3, 0.4],),
+    ([-91, 0, 1, 2, 3, 4, 5, 6, 7, 8],),
+    (list(range(50, 1000)),),
+    (["aaaa", "aaaa", "aaaa"],),
+    ([1, "asdg", b"234sa", 4.5, [1, 2, 3, 4, 5], False, [], None],),
+
+    ({"a": "sdgaeiogn", "waegw": 123, "sdagweg": list(range(10)), "aegsag": {"asdg": 235, "Asg": b"asg"}},),
+    ({1: "afdbda", "ar": "23wesd", False: 23453, 1234: 12324356, "": {"sgdfn32rwefsdvre": 34}},),
+
+    ({"a": "sdgaeiogn", "content": b"1243567" * 1024 * 1024 * 50, "sdagweg": list(range(10)),
+      "aegsag": {"asdg": 235, "Asg": b"asg"}},),
+    pytest.param([True, False, False] * 1000, id="list of booleans"),
+]
+
+
+@pytest.mark.parametrize(
+    ["obj"],
+    ALL_TYPES_OF_OBJECTS
+)
+def test__serialize_deserialize__modify_input(obj):
+    # Arrange
+    original_obj = copy.deepcopy(obj)
+
+    # Act
+    serialized = pinch_python.dump_bytes(obj, modify_input=True)
+    unserialized = pinch_python.load_bytes(serialized)
+
+    # Assert
+    assert unserialized == original_obj
+
+
+def test__serialize_deserialize__nan():
+    # Act
+    serialized = pinch_python.dump_bytes(float("nan"))
+    unserialized = pinch_python.load_bytes(serialized)
+
+    # Assert
+    assert math.isnan(unserialized)
+
+@pytest.mark.parametrize(
+    ["input_tuple", "expected"],
+    [
+        (tuple(), []),
+        ((1, 2, 3), [1, 2, 3]),
+        ((((),),), [[[]]]),
+        ((1, None, 2.3, "rtjg", b"5y4rthf", [], {}, tuple()), [1, None, 2.3, "rtjg", b"5y4rthf", [], {}, []]),
+    ]
+)
+def test__tuples_serialize_deserialize__into_list(input_tuple, expected):
+    # Act
+    serialized = pinch_python.dump_bytes(float("nan"))
+    unserialized = pinch_python.load_bytes(serialized)
+
+    # Assert
+    assert math.isnan(unserialized)
+
+@pytest.mark.parametrize(
+    ["obj", "expected"],
+    [
+        (datetime.datetime(2026, 10, 4, 23, 2, 9, 53, tzinfo=datetime.timezone.utc), "2026-10-04T23:02:09.000053+00:00"),
+        (
+            [
+                datetime.datetime(2026, 10, 4, 23, 2, 9, 53, tzinfo=datetime.timezone.utc),
+                datetime.datetime(1995, 1, 2, 6, 3, 18, tzinfo=ZoneInfo("America/Los_Angeles")),
+                datetime.datetime(2050, 4, 1, tzinfo=ZoneInfo("Asia/Kolkata")),
+            ],
+            [
+                "2026-10-04T23:02:09.000053+00:00",
+                "1995-01-02T06:03:18-08:00",
+                "2050-04-01T00:00:00+05:30",
+            ]
+        ),
+    ]
+)
+def test__serialize_unknown_types(obj, expected):
+    # Act
+    serialized = pinch_python.dump_bytes(obj)
+    unserialized = pinch_python.load_bytes(serialized)
+
+    # Assert
+    assert unserialized == expected
+
+
+@pytest.mark.parametrize(
+    ["obj"],
+    ALL_TYPES_OF_OBJECTS
+)
+def test__serialize_deserialize__with_pointers(obj):
+    # Arrange
+    original_obj = copy.deepcopy(obj)
+
+    # Act
+    serialized = pinch_python.dump_bytes(obj, use_pointers=True)
+    unserialized = pinch_python.load_bytes(serialized)
+
+    # Assert
+    assert unserialized == original_obj
+
+
+@pytest.mark.parametrize(
+    ["obj"],
+    ALL_TYPES_OF_OBJECTS
+)
+def test__serialize_deserialize__dont_modify_input(obj):
+    # Arrange
+    original_obj = copy.deepcopy(obj)
+
+    # Act
+    serialized = pinch_python.dump_bytes(obj, modify_input=False)
+    unserialized = pinch_python.load_bytes(serialized)
+
+    # Assert
+    assert unserialized == original_obj
+    assert obj == original_obj
+
+
+@pytest.mark.parametrize(
+    ["obj"],
+    ALL_TYPES_OF_OBJECTS
+)
+def test__serialize_deserialize__dont_modify_serialized_data(obj):
+    # Arrange
+    original_obj = copy.deepcopy(obj)
+    serialized = pinch_python.dump_bytes(obj)
+    original_serialized = copy.deepcopy(serialized)
+
+    # Act
+    unserialized = pinch_python.load_bytes(serialized, modify_input=False)
+
+    # Assert
+    assert unserialized == original_obj
+    assert serialized == original_serialized
+
+
+@pytest.mark.parametrize(
+    ["obj"],
+    ALL_TYPES_OF_OBJECTS
+)
+def test__serialize_deserialize__modify_serialized_data(obj):
+    # Arrange
+    original_obj = copy.deepcopy(obj)
+    serialized = pinch_python.dump_bytes(obj)
+
+    # Act
+    unserialized = pinch_python.load_bytes(serialized, modify_input=True)
+
+    # Assert
+    assert unserialized == original_obj
+
+
+@pytest.mark.parametrize(
+    ["obj"],
+    ALL_TYPES_OF_OBJECTS
+)
+def test__serialize_deserialize__bytes_serialized_data(obj):
+    # Arrange
+    original_obj = copy.deepcopy(obj)
+    serialized = bytes(pinch_python.dump_bytes(obj))
+
+    # Act
+    unserialized = pinch_python.load_bytes(serialized, modify_input=True)
+
+    # Assert
+    assert unserialized == original_obj
+
+
+@pytest.mark.parametrize(
+    ["obj", "expected"],
+    [
+        ([1, 2, 3], (1, 2, 3)),
+        ({"a": [], "b": [[1], ["f"]]}, {"a": tuple(), "b": ((1,), ("f",))}),
+    ]
+)
+def test__serialize_deserialize__use_tuples(obj, expected):
+    # Act
+    serialized = pinch_python.dump_bytes(obj)
+    unserialized = pinch_python.load_bytes(serialized, use_tuples=True, modify_input=True)
+
+    # Assert
+    assert unserialized == expected
+
+
+@pytest.mark.parametrize(
+    ["obj", "encoding"],
+    [
+        ("abcdef", "utf-16"),
+        ("abcdef", "utf-32-le"),
+        ("abcdef", "ascii"),
+        ("abcdef", "cp775"),
+        ("abcdef", "windows-1256"),
+    ]
+)
+def test__serialize_deserialize__with_encoding(obj, encoding):
+    # Arrange
+    original_object = copy.deepcopy(obj)
+
+    # Act
+    serialized = pinch_python.dump_bytes(obj, encoding=encoding)
+    unserialized = pinch_python.load_bytes(serialized, modify_input=True, encoding=encoding)
+
+    # Assert
+    assert unserialized == original_object