binsl 0.1__tar.gz

binsl-0.1/LICENSE

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

binsl-0.1/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: binsl
+Version: 0.1
+Summary: Small binary reader/writer library for Python.
+Author-email: stas96111 <stas96111@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 stas96111
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/stas96111/binsl
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+Small binary reader/writer library for Python.

binsl-0.1/README.md

@@ -0,0 +1 @@
+Small binary reader/writer library for Python.

binsl-0.1/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "binsl"
+version = "0.1"
+authors = [
+  { name = "stas96111", email = "stas96111@gmail.com" },
+]
+description = "Small binary reader/writer library for Python."
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = []
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = {file = "LICENSE"}
+
+[tool.setuptools]
+license-files = []
+
+[project.urls]
+Homepage = "https://github.com/stas96111/binsl"

binsl-0.1/setup.cfg

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

binsl-0.1/src/binsl/__init__.py

@@ -0,0 +1 @@
+from .binsl import BinReader, BinWriter, Position, Endian

binsl-0.1/src/binsl/binsl.py

@@ -0,0 +1,743 @@
+import mmap
+import struct
+from contextlib import contextmanager
+from enum import IntEnum, StrEnum
+from io import SEEK_CUR, SEEK_END, SEEK_SET
+from pathlib import Path
+
+HEX_TABLE = [f"{i:02X}" for i in range(256)]
+
+ASCII_TABLE = [
+    chr(i) if 32 <= i <= 126 else "."
+    for i in range(256)
+]
+
+_STRUCTS = {
+    "<": {
+        "u8": struct.Struct("<B"),
+        "u16": struct.Struct("<H"),
+        "u32": struct.Struct("<I"),
+        "u64": struct.Struct("<Q"),
+        "i8": struct.Struct("<b"),
+        "i16": struct.Struct("<h"),
+        "i32": struct.Struct("<i"),
+        "i64": struct.Struct("<q"),
+        "f": struct.Struct("<f"),
+        "d": struct.Struct("<d"),
+    },
+    ">": {
+        "u8": struct.Struct(">B"),
+        "u16": struct.Struct(">H"),
+        "u32": struct.Struct(">I"),
+        "u64": struct.Struct(">Q"),
+        "i8": struct.Struct(">b"),
+        "i16": struct.Struct(">h"),
+        "i32": struct.Struct(">i"),
+        "i64": struct.Struct(">q"),
+        "f": struct.Struct(">f"),
+        "d": struct.Struct(">d"),
+    },
+}
+
+class Position(IntEnum):
+    CURRENT = SEEK_CUR
+    END = SEEK_END
+    SET = SEEK_SET
+
+
+class Endian(StrEnum):
+    BIG = ">"
+    LITTLE = "<"
+
+
+class BinReader:
+    """Create binary reader.
+
+        Args:
+            file: Path | str | bytes | None
+            endian: Endian
+            
+        ```python
+        reader = BinReader()
+        
+        with BinReader() as reader:
+            pass
+        ```
+    """
+    __slots__ = (
+        "path",
+        "size",
+        "pos",
+        "endian",
+        "_mm",
+        "_view",
+        "_file_obj",
+        "_u8",
+        "_u16",
+        "_u32",
+        "_u64",
+        "_i8",
+        "_i16",
+        "_i32",
+        "_i64",
+        "_f",
+        "_d",
+    )
+
+    def __init__(self, file: Path | str | bytes = b"", endian: Endian = Endian.LITTLE) -> BinReader:
+        self.path = None
+        self.size = 0
+        self.pos = 0
+        self.set_endian(endian)
+
+        self._mm = None
+        self._view = None
+        self._file_obj = None
+        
+        if isinstance(file, (str, Path)):
+            self.path = str(file)
+            self._file_obj = open(file, "rb")
+            self._mm = mmap.mmap(self._file_obj.fileno(), 0, access=mmap.ACCESS_READ)
+            self._view = memoryview(self._mm)
+            self.size = len(self._mm)
+        elif isinstance(file, (bytes, bytearray)):
+            self._mm = None  # IMPORTANT
+            self._view = memoryview(file)
+            self.size = len(file)
+        else:
+            raise ValueError("File must be: str(path), bytes, or bytearray.")
+
+    def set_endian(self, endian: Endian = Endian.LITTLE):
+        """Change endines of the reader.
+
+        Args:
+            endian: Endian
+            
+        ```python
+        reader.set_endian(Endian.Big)
+        ```
+        """
+        self.endian = endian
+        s = _STRUCTS[endian]
+        self._u8 = s["u8"]
+        self._u16 = s["u16"]
+        self._u32 = s["u32"]
+        self._u64 = s["u64"]
+        self._i8 = s["i8"]
+        self._i16 = s["i16"]
+        self._i32 = s["i32"]
+        self._i64 = s["i64"]
+        self._f = s["f"]
+        self._d = s["d"]
+    
+    def _check(self, size):
+        if self.pos + size > self.size:
+            raise EOFError("Read beyond end")
+
+    def get_pos(self):
+        """Get cursor possition of the cursor.
+        """
+        return self.pos
+
+    def set_pos(self, position: int, where=Position.SET):
+        """Set cursor possition of the cursor.
+
+        Args:
+            position: int
+            where: Possition.
+        """
+        if where == Position.CURRENT:
+            self.pos += position
+        elif where == Position.END:
+            self.pos = self.size - abs(position)
+        elif where == Position.SET:
+            self.pos = position
+            
+        if not (0 <= self.pos <= self.size):
+            raise ValueError("Position out of bounds.")
+
+    def skip(self, offset: int):
+        """Move the current position forward by a given offset.
+
+        Args:
+            offset: Number of bytes to skip from the current position.
+        """
+        self.set_pos(offset, SEEK_CUR)
+
+    def get_size(self):
+        return self.size
+    
+    def align(self, alignment):
+        self.pos = (self.pos + alignment - 1) & ~(alignment - 1)
+        if self.pos > self.size:
+            raise EOFError("Alignment beyond EOF")
+
+    def read(self, size: int) -> bytes:
+        """Read a number of bytes from the current position.
+
+        Args:
+            size: Number of bytes to read.
+
+        Returns:
+            The bytes that were read.
+        """
+        pos = self.pos
+        end = pos + size
+        if end > self.size:
+            raise EOFError(f"Attempt to read {size} beyond the end of the file.")
+        data = self._view[pos:end]
+        self.pos = end
+        return data.tobytes()
+
+    def read_int(self, size: int, signed: bool = False, byteorder="little") -> int:
+        """Read an integer from the current position.
+
+        Args:
+            size: Number of bytes to read.
+            signed: Whether the integer is signed.
+            byteorder: Byte order ('little' or 'big').
+
+        Returns:
+            The integer value decoded from the bytes.
+        """
+        val = self._view[self.pos : self.pos + size]
+        self.pos += size
+        return int.from_bytes(val, byteorder=byteorder, signed=signed)
+
+    def uint8(self) -> int:
+        """Read an unsigned 8-bit integer."""
+        self._check(1)
+        val = self._u8.unpack_from(self._view, self.pos)[0]
+        self.pos += 1
+        return val
+
+    def uint16(self) -> int:
+        """Read an unsigned 16-bit integer."""
+        self._check(2)
+        val = self._u16.unpack_from(self._view, self.pos)[0]
+        self.pos += 2
+        return val
+
+    def uint32(self) -> int:
+        """Read an unsigned 32-bit integer."""
+        self._check(4)
+        val = self._u32.unpack_from(self._view, self.pos)[0]
+        self.pos += 4
+        return val
+
+    def uint64(self) -> int:
+        """Read an unsigned 64-bit integer."""
+        self._check(8)
+        val = self._u64.unpack_from(self._view, self.pos)[0]
+        self.pos += 8
+        return val
+    
+    def uint128(self) -> int:
+        """Read an unsigned 128-bit integer."""
+        self._check(16)
+        val = int.from_bytes(
+            self._view[self.pos : self.pos + 16],
+            byteorder="little" if self.endian == "<" else "big",
+            signed=False,
+        )
+
+        self.pos += 16
+        return val
+
+    def int8(self) -> int:
+        """Read a signed 8-bit integer."""
+        self._check(1)
+        val = self._i8.unpack_from(self._view, self.pos)[0]
+        self.pos += 1
+        return val
+
+    def int16(self) -> int:
+        """Read a signed 16-bit integer."""
+        self._check(2)
+        val = self._i16.unpack_from(self._view, self.pos)[0]
+        self.pos += 2
+        return val
+
+    def int32(self) -> int:
+        """Read a signed 32-bit integer."""
+        self._check(4)
+        val = self._i32.unpack_from(self._view, self.pos)[0]
+        self.pos += 4
+        return val
+
+    def int64(self) -> int:
+        """Read a signed 64-bit integer."""
+        self._check(8)
+        val = self._i64.unpack_from(self._view, self.pos)[0]
+        self.pos += 8
+        return val
+    
+    def int128(self) -> int:
+        """Read a signed 128-bit integer."""
+        self._check(16)
+        val = int.from_bytes(
+            self._view[self.pos : self.pos + 16],
+            byteorder="little" if self.endian == "<" else "big",
+            signed=True,
+        )
+
+        self.pos += 16
+        return val
+
+    def float(self) -> float:
+        """Read an 32-bit float value."""
+        self._check(4)
+        val = self._f.unpack_from(self._view, self.pos)[0]
+        self.pos += 4
+        return val
+
+    def double(self) -> float:
+        """Read an 64-bit float value."""
+        self._check(8)
+        val = self._d.unpack_from(self._view, self.pos)[0]
+        self.pos += 8
+        return val
+
+    def bool(self) -> bool:
+        """Read a boolean value."""
+        val = self.uint8()
+        return val != 0
+    
+    def string(self, encoding="utf-8", size=None) -> str:
+        """Read a string.
+        
+            Args:
+                encoding: Text encoding used to decode the bytes.
+                length: Number of bytes to read.
+        """
+        if size is None:
+            size = self.uint32()
+
+        end = self.pos + size
+
+        if end > self.size:
+            raise EOFError("String larger than the file size.")
+
+        data = self._view[self.pos:end].tobytes()
+        self.pos = end
+
+        return data.decode(encoding)
+    
+    def cstring(self, encoding="utf-8") -> str:
+        """Read a C-like string.
+        
+            Args:
+                encoding: Text encoding used to decode the bytes.
+                length: Number of bytes to read.
+        """
+        start = self.pos
+        mv = self._view
+        size = self.size
+
+        while self.pos < size:
+            if mv[self.pos] == 0:
+                break
+            self.pos += 1
+        else:
+            raise EOFError("Unterminated C-string")
+
+        data = mv[start:self.pos].tobytes()
+        self.pos += 1
+
+        return data.decode(encoding)
+
+    def list(self, func, length=None):
+        """Read a list of items using a parser function.
+
+        Args:
+            func: Function that reads a single element from reader.
+            length: Number of items to read.
+
+        Returns:
+            List of parsed items.
+        """
+    
+        if length is None:
+            length = self.uint32()
+        return [func(self) for _ in range(length)]
+
+    def buffer(self, offset, size):
+        """Create a sub-reader from a slice of the buffer.
+
+        Args:
+            offset: Start position of the slice.
+            size: Number of bytes to include.
+
+        Returns:
+            A new BinReader instance.
+            
+        ```python
+        with reader.buffer(size=200) as buffer:
+            value = buffer.uint8()
+        ```
+        """
+        
+        if offset is None:
+            offset = self.pos
+            
+        if offset < 0 or offset + size > self.size:
+            raise EOFError("Buffer out of bounds")
+
+        data = self._view[offset: offset + size]
+        return BinReader(data, endian=self.endian)
+
+    def remain(self, size: int):
+        return self.size - self.pos >= size
+    
+    def hexdump(self, offset = None, size = None, width = 16, height = None, group = 8):
+        """Return hex dump of file."""
+        if offset is None:
+            offset = self.pos
+
+        if height is not None:
+            size = width * height
+
+        if size is None:
+            size = min(256, self.size - offset)
+
+        end = min(offset + size, self.size)
+
+        lines = []
+
+        header_parts = []
+
+        for i in range(width):
+            if i and i % group == 0:
+                header_parts.append(" ")
+
+            header_parts.append(HEX_TABLE[i])
+
+        lines.append("Hex Dump  " + " ".join(header_parts))
+        lines.append("")
+
+        view = self._view
+
+        for row in range(offset, end, width):
+            chunk = view[row:min(row + width, end)]
+
+            hex_parts = []
+            ascii_parts = []
+
+            for i, b in enumerate(chunk):
+                if i and i % group == 0:
+                    hex_parts.append(" ")
+
+                hex_parts.append(HEX_TABLE[b])
+                ascii_parts.append(ASCII_TABLE[b])
+
+            hex_text = " ".join(hex_parts)
+
+            expected_width = width * 3 + ((width - 1) // group)
+            hex_text = hex_text.ljust(expected_width)
+
+            ascii_text = "".join(ascii_parts)
+
+            lines.append(
+                f"{row:08X}  {hex_text}  {ascii_text}"
+            )
+
+        return "\n".join(lines)
+
+    @contextmanager
+    def at(self, offset):
+        """Temporarily move the read position to an offset.
+
+        Args:
+            offset: Position to temporarily move to.
+            
+        ```python
+        with reader.at(offset) as temp_reader:
+            value = temp_reader.uint8()
+        ```
+        """
+        old = self.pos
+        self.pos = offset
+        try:
+            yield self
+        finally:
+            self.pos = old
+    
+    def close(self):
+        if self._view is not None:
+            self._view.release()
+            self._view = None
+
+        if self._mm is not None:
+            self._mm.close()
+            self._mm = None
+
+        if self._file_obj is not None:
+            self._file_obj.close()
+            self._file_obj = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
+
+class BinWriter:
+    __slots__ = (
+        "path",
+        "size",
+        "pos",
+        "endian",
+        "_mm",
+        "_view",
+        "_file_obj",
+        "_buf",
+        "_u8",
+        "_u16",
+        "_u32",
+        "_u64",
+        "_i8",
+        "_i16",
+        "_i32",
+        "_i64",
+        "_f",
+        "_d",
+    )
+
+    def __init__(
+        self, file: str | Path | bytes | bytearray | None = None, endian: Endian = Endian.LITTLE, initial_size=1024, append=False
+    ):
+        """
+        file:
+          - str  -> file path (mmap-backed)
+          - None -> in-memory (bytearray)
+        """
+        self.path = None
+        self.pos = 0
+        self.size = 0
+        self._mm = None
+        self._view = None
+        self._file_obj = None
+        self._buf = None
+
+        self.set_endian(endian)
+
+
+        if isinstance(file, (str, Path)):
+            exists = Path(file).exists()
+            if append and exists:
+                self._file_obj = open(file, "r+b")
+                self._file_obj.seek(0, SEEK_END)
+                existing = self._file_obj.tell()
+                map_size = max(existing, initial_size)
+                if existing < map_size:
+                    self._file_obj.write(b"\x00" * (map_size - existing))
+                    self._file_obj.flush()
+                self.pos = existing
+            else:
+                self._file_obj = open(file, "w+b")
+                self._file_obj.write(b"\x00" * initial_size)
+                self._file_obj.flush()
+                map_size = initial_size
+                self.pos = 0
+            self.size = map_size
+            self._mm = mmap.mmap(self._file_obj.fileno(), map_size)
+            self._view = memoryview(self._mm)
+            
+        elif isinstance(file, (bytes, bytearray)):
+            self._buf = bytearray(file)             # copy into a mutable bytearray
+            self._view = memoryview(self._buf)
+            self.size = len(self._buf)
+            self.pos = len(self._buf)
+
+        elif file is None:
+            self._buf = bytearray(initial_size)
+            self._view = memoryview(self._buf)
+            self.size = initial_size
+
+        else:
+            raise ValueError("Writer file must be: str(path) or None")
+
+    def _ensure(self, needed: int):
+        if self.pos + needed <= self.size:
+            return
+
+        new_size = max(self.size * 2, self.pos + needed)
+
+        if self._mm is not None:
+            if self._view is not None:
+                self._view.release()
+                self._view = None
+
+            self._mm.resize(new_size)
+            self._view = memoryview(self._mm)
+
+        else:
+            # Release memoryview before resizing bytearray
+            if self._view is not None:
+                self._view.release()
+                self._view = None
+
+            self._buf.extend(b"\x00" * (new_size - self.size))
+            self._view = memoryview(self._buf)
+
+        self.size = new_size
+
+    def set_endian(self, endian: Endian):
+        self.endian = endian
+        s = _STRUCTS[endian]
+        self._u8 = s["u8"]
+        self._u16 = s["u16"]
+        self._u32 = s["u32"]
+        self._u64 = s["u64"]
+        self._i8 = s["i8"]
+        self._i16 = s["i16"]
+        self._i32 = s["i32"]
+        self._i64 = s["i64"]
+        self._f = s["f"]
+        self._d = s["d"]
+
+    def get_pos(self):
+        return self.pos
+
+    def set_pos(self, position: int, where=Position.CURRENT):
+        if where == Position.SET:
+            self.pos = position
+        elif where == Position.CURRENT:
+            self.pos += position
+        elif where == Position.END:
+            self.pos = self.size - abs(position)
+        else:
+            raise ValueError("Invalid seek mode")
+
+    def skip(self, offset: int):
+        self.pos += offset
+
+    def write(self, data: bytes | bytearray | memoryview):
+        n = len(data)
+        self._ensure(n)
+        self._view[self.pos : self.pos + n] = data
+        self.pos += n
+
+    def uint8(self, v: int):
+        self._ensure(1)
+        self._u8.pack_into(self._view, self.pos, v)
+        self.pos += 1
+
+    def uint16(self, v: int):
+        self._ensure(2)
+        self._u16.pack_into(self._view, self.pos, v)
+        self.pos += 2
+
+    def uint32(self, v: int):
+        self._ensure(4)
+        self._u32.pack_into(self._view, self.pos, v)
+        self.pos += 4
+
+    def uint64(self, v: int):
+        self._ensure(8)
+        self._u64.pack_into(self._view, self.pos, v)
+        self.pos += 8
+
+    def uint128(self, v: int):
+        self._ensure(16)
+        self._view[self.pos : self.pos + 16] = v.to_bytes(
+            16, "little" if self.endian == "<" else "big", signed=False
+        )
+        self.pos += 16
+
+    def int8(self, v: int):
+        self._ensure(1)
+        self._i8.pack_into(self._view, self.pos, v)
+        self.pos += 1
+
+    def int16(self, v: int):
+        self._ensure(2)
+        self._i16.pack_into(self._view, self.pos, v)
+        self.pos += 2
+
+    def int32(self, v: int):
+        self._ensure(4)
+        self._i32.pack_into(self._view, self.pos, v)
+        self.pos += 4
+
+    def int64(self, v: int):
+        self._ensure(8)
+        self._i64.pack_into(self._view, self.pos, v)
+        self.pos += 8
+
+    def int128(self, v: int):
+        self._ensure(16)
+        self._view[self.pos : self.pos + 16] = v.to_bytes(
+            16, "little" if self.endian == "<" else "big", signed=True
+        )
+        self.pos += 16
+
+    def float(self, v: float):
+        self._ensure(4)
+        self._f.pack_into(self._view, self.pos, v)
+        self.pos += 4
+        
+    def double(self, v: float):
+        self._ensure(8)
+        self._d.pack_into(self._view, self.pos, v)
+        self.pos += 8
+
+    def bool(self, v: bool):
+        self.uint8(1 if v else 0)
+
+    def get_bytes(self) -> bytes:
+        if self._mm is not None:
+            return self._mm[:self.pos]
+
+        if self._buf is not None:
+            return bytes(self._buf[:self.pos])
+
+        return b""
+            
+    def string(self, value: str, encoding="utf-8", length=None):
+        data = value.encode(encoding)
+        if length is None:
+            length = len(data)
+        self.uint32(length)
+        self.write(data)
+
+    def cstring(self, value: str, encoding="utf-8"):
+        data = value.encode(encoding) + b"\x00"
+        self.write(data)
+
+    def list(self, items, write_func, length=None):
+        if length is None:
+            self.uint32(len(items))
+        for item in items:
+            write_func(item)
+            
+    @contextmanager
+    def at(self, offset):
+        old = self.pos
+        self.pos = offset
+        try:
+            yield self
+        finally:
+            self.pos = old
+            
+    def close(self):
+        if self._view is not None:
+            self._view.release()
+            self._view = None
+
+        if self._mm is not None:
+            self._mm.flush()
+            self._mm.close()
+            self._mm = None
+
+        if self._file_obj is not None:
+            self._file_obj.truncate(self.pos)
+            self._file_obj.close()
+            self._file_obj = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()

binsl-0.1/src/binsl.egg-info/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: binsl
+Version: 0.1
+Summary: Small binary reader/writer library for Python.
+Author-email: stas96111 <stas96111@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 stas96111
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/stas96111/binsl
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+Small binary reader/writer library for Python.

binsl-0.1/src/binsl.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+src/binsl/__init__.py
+src/binsl/binsl.py
+src/binsl.egg-info/PKG-INFO
+src/binsl.egg-info/SOURCES.txt
+src/binsl.egg-info/dependency_links.txt
+src/binsl.egg-info/top_level.txt

binsl-0.1/src/binsl.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

binsl-0.1/src/binsl.egg-info/top_level.txt

@@ -0,0 +1 @@
+binsl