tsrkit-types 0.1.8__py3-none-any.whl → 0.1.9__py3-none-any.whl

tsrkit_types/__init__.py

@@ -90,6 +90,6 @@ __all__ = [
 ]
 
 # Version information
-__version__ = "1.0.0"
+__version__ = "0.1.9"
 __author__ = "TSRKit Team"
 __license__ = "MIT"

tsrkit_types/bytes.py

@@ -4,6 +4,7 @@ from tsrkit_types.integers import Uint
 from tsrkit_types.itf.codable import Codable
 from tsrkit_types.bytes_common import BytesMixin
 
+
 class BytesCheckMeta(abc.ABCMeta):
     """Meta class to check if the instance is a bytes with the same key and value types"""
     def __instancecheck__(cls, instance):
@@ -58,8 +59,20 @@ class Bytes(bytes, Codable, BytesMixin, metaclass=BytesCheckMeta):
         
         if len(buffer[current_offset:current_offset+_len]) < _len:
             raise TypeError("Insufficient buffer")
-        return cls(buffer[current_offset:current_offset+_len]), current_offset + _len - offset
-    
+        
+        result = (cls(buffer[current_offset:current_offset+_len]), current_offset + _len - offset)
+        
+        return result
+
+    def __deepcopy__(self, memo):
+        # immutable; safe to reuse or create a new same-typed instance
+        existing = memo.get(id(self))
+        if existing is not None:
+            return existing
+        new = type(self)(bytes(self))
+        memo[id(self)] = new
+        return new
+
     # ---------------------------------------------------------------------------- #
     #                               JSON Serialization                             #
     # ---------------------------------------------------------------------------- #

tsrkit_types/bytes_common.py

@@ -4,6 +4,23 @@ Common functionality for Bytes and ByteArray types.
 
 from typing import Union
 
+# Global lookup tables for maximum performance - initialized once
+_BYTE_TO_BITS_MSB = []
+_BITS_TO_BYTE_MSB = {}
+_TABLES_INITIALIZED = False
+
+def _init_lookup_tables():
+    """Initialize lookup tables once for optimal performance."""
+    global _BYTE_TO_BITS_MSB, _BITS_TO_BYTE_MSB, _TABLES_INITIALIZED
+    if not _TABLES_INITIALIZED:
+        for i in range(256):
+            # Convert byte to 8 bits (MSB first)
+            bits = [(i >> (7 - j)) & 1 for j in range(8)]
+            _BYTE_TO_BITS_MSB.append(bits)
+            # Reverse lookup: bits tuple to byte value
+            _BITS_TO_BYTE_MSB[tuple(bits)] = i
+        _TABLES_INITIALIZED = True
+
 
 class BytesMixin:
     """Mixin providing common functionality for bytes-like types."""
@@ -11,42 +28,57 @@ class BytesMixin:
     @classmethod
     def from_bits(cls, bits: list[bool], bit_order: str = "msb"):
         """Convert a list of bits to bytes with specified bit order."""
-        # Sanitize input: make sure bits are 0 or 1
-        bits = [int(bool(b)) for b in bits]
-        n = len(bits)
-        # Pad with zeros to multiple of 8
-        pad = (8 - n % 8) % 8
-        bits += [0] * pad
-
-        byte_arr = []
-        for i in range(0, len(bits), 8):
-            byte_bits = bits[i:i + 8]
-            if bit_order == "msb":
-                # Most significant bit first
-                val = 0
-                for bit in byte_bits:
-                    val = (val << 1) | bit
-            elif bit_order == "lsb":
-                # Least significant bit first
+        # Fast path for MSB (most common case) using lookup tables
+        if bit_order == "msb":
+            _init_lookup_tables()
+            
+            # Convert and pad to multiple of 8
+            int_bits = [int(bool(b)) for b in bits]
+            pad = (8 - len(int_bits) % 8) % 8
+            int_bits.extend([0] * pad)
+            
+            result = []
+            for i in range(0, len(int_bits), 8):
+                byte_bits = tuple(int_bits[i:i+8])
+                result.append(_BITS_TO_BYTE_MSB[byte_bits])
+            return cls(bytes(result))
+        
+        # LSB implementation
+        elif bit_order == "lsb":
+            int_bits = [int(bool(b)) for b in bits]
+            pad = (8 - len(int_bits) % 8) % 8
+            int_bits.extend([0] * pad)
+            
+            result = []
+            for i in range(0, len(int_bits), 8):
+                byte_bits = int_bits[i:i + 8]
                 val = 0
                 for bit in reversed(byte_bits):
                     val = (val << 1) | bit
-            else:
-                raise ValueError(f"Unknown bit_order: {bit_order}")
-            byte_arr.append(val)
-        return cls(bytes(byte_arr))
+                result.append(val)
+            return cls(bytes(result))
+        else:
+            raise ValueError(f"Unknown bit_order: {bit_order}")
 
     def to_bits(self, bit_order: str = "msb") -> list[bool]:
         """Convert bytes to a list of bits with specified bit order."""
-        bits = []
-        for byte in self:
-            if bit_order == "msb":
-                bits.extend([bool((byte >> i) & 1) for i in reversed(range(8))])
-            elif bit_order == "lsb":
+        # Fast path for MSB using lookup table
+        if bit_order == "msb":
+            _init_lookup_tables()
+            
+            result = []
+            for byte in self:
+                result.extend(_BYTE_TO_BITS_MSB[byte])
+            return [bool(b) for b in result]
+        
+        # LSB implementation
+        elif bit_order == "lsb":
+            bits = []
+            for byte in self:
                 bits.extend([bool((byte >> i) & 1) for i in range(8)])
-            else:
-                raise ValueError(f"Unknown bit_order: {bit_order}")
-        return bits
+            return bits
+        else:
+            raise ValueError(f"Unknown bit_order: {bit_order}")
     
     def to_json(self):
         """Convert bytes to hex string for JSON serialization."""
@@ -61,6 +93,40 @@ class BytesMixin:
     def __str__(self):
         return f"{self.__class__.__name__}({self.hex()})"
 
+    def slice_bits(self, start_bit: int, end_bit: int) -> list[bool]:
+        """Extract bit slice efficiently without converting entire byte array."""
+        if start_bit >= end_bit:
+            return []
+        
+        start_byte = start_bit // 8
+        end_byte = (end_bit - 1) // 8 + 1
+        start_bit_offset = start_bit % 8
+        
+        if start_byte >= len(self):
+            return [False] * (end_bit - start_bit)
+        
+        # Extract relevant bytes and convert only what we need
+        relevant_bytes = self[start_byte:min(end_byte, len(self))]
+        
+        # Use global lookup table for optimal performance
+        _init_lookup_tables()
+        
+        result = []
+        for byte in relevant_bytes:
+            result.extend(_BYTE_TO_BITS_MSB[byte])
+        
+        # Slice to exact range
+        local_start = start_bit_offset if start_byte < len(self) else 0
+        local_end = len(result) if end_byte > len(self) else (end_bit - start_byte * 8)
+        
+        bits = result[local_start:local_end]
+        
+        # Pad with False if we ran out of data
+        if len(bits) < (end_bit - start_bit):
+            bits.extend([False] * (end_bit - start_bit - len(bits)))
+        
+        return [bool(b) for b in bits]
+
 
 def validate_bit_order(bit_order: str) -> None:
     """Validate bit order parameter."""

tsrkit_types/choice.py

@@ -3,7 +3,7 @@ from typing import ClassVar, Optional, Union, Tuple, Any
 from tsrkit_types.integers import Uint
 from tsrkit_types.itf.codable import Codable
 
-ChoiceType = Tuple[Optional[str], type] | type
+ChoiceType = Union[Tuple[Optional[str], type], type]
 
 class Choice(Codable):
     """
@@ -43,7 +43,7 @@ class Choice(Codable):
     def _choice_keys(self) -> Tuple[Optional[str]]:
         return tuple(self._choice[0] for self._choice in self._opt_types)
 
-    def __class_getitem__(cls, opt_t: Tuple[type] | type):
+    def __class_getitem__(cls, opt_t: Union[Tuple[type], type]):
         _opt_types = []
         if isinstance(opt_t, type):
             _opt_types.append((None, opt_t))
@@ -98,7 +98,7 @@ class Choice(Codable):
         return self._value.to_json() if not self._choice_key else {self._choice_key: self._value.to_json()}
 
     @classmethod
-    def from_json(cls, data: dict | Any) -> "Choice":
+    def from_json(cls, data: Union[dict, Any]) -> "Choice":
         if isinstance(data, dict):
             opt_type = next((x for x in cls._opt_types if x[0] == list(data.keys())[0]), None)
             if opt_type is None:
@@ -132,4 +132,4 @@ class Choice(Codable):
         tag, tag_size = Uint.decode_from(buffer, offset)
         value, val_size = cls._opt_types[tag][1].decode_from(buffer, offset+tag_size)
 
-        return cls(value), tag_size+val_size
+        return cls(value, key=cls._opt_types[tag][0]), tag_size+val_size

tsrkit_types/dictionary.py

@@ -126,7 +126,7 @@ class Dictionary(dict, Codable, Generic[K, V], metaclass=DictCheckMeta):
     def encode_into(self, buffer: bytearray, offset: int = 0) -> int:
         current_offset = offset
         current_offset += Uint(len(self)).encode_into(buffer, current_offset)
-        for k, v in sorted(self.items(), key=lambda x: x[0].encode()):
+        for k, v in sorted(self.items(), key=lambda x: x[0]):
             current_offset += k.encode_into(buffer, current_offset)
             current_offset += v.encode_into(buffer, current_offset)
         return current_offset - offset

tsrkit_types/integers.py

@@ -1,7 +1,18 @@
 import abc
 from decimal import Decimal
 import math
-from typing import Any, Tuple, Union, Callable
+from typing import Any, Optional, Tuple, Union, Callable
+
+try:
+    from typing import Self
+except ImportError:
+    # For Python < 3.11, use TYPE_CHECKING and forward reference
+    from typing import TYPE_CHECKING
+    if TYPE_CHECKING:
+        from typing import Self
+    else:
+        Self = "Uint"  # Forward reference string
+
 from tsrkit_types.itf.codable import Codable
 
 
@@ -54,8 +65,9 @@ class Int(int, Codable, metaclass=IntCheckMeta):
     byte_size: int = 0
     signed = False
     _bound = 1 << 64
-
-    def __class_getitem__(cls, data: int | tuple | bool | None):
+    
+    @classmethod
+    def __class_getitem__(cls, data: Optional[Union[int, tuple, bool]]):
         """
         Args:
             data: either byte_size or (byte_size, signed)
@@ -230,7 +242,7 @@ class Int(int, Codable, metaclass=IntCheckMeta):
             raise ValueError(f"Invalid bit order: {bit_order}")
         
     @classmethod
-    def from_bits(cls, bits: list[bool], bit_order: str = "msb") -> "Uint":
+    def from_bits(cls, bits: list[bool], bit_order: str = "msb") -> "Int":
         """Convert bits to an int"""
         if bit_order == "msb":
             return cls(int("".join(str(int(b)) for b in bits), 2))

tsrkit_types/itf/codable.py

@@ -80,4 +80,7 @@ class Codable(ABC, Generic[T]):
             offset: The offset at which to start encoding the value.
         """
         if len(buffer) - offset < size:
-            raise ValueError("Buffer too small to encode value")
+            raise ValueError("Buffer too small to encode value")
+
+    def __reduce__(self):
+        return (self.__class__.decode, (self.encode(),))

tsrkit_types/option.py

@@ -18,7 +18,7 @@ class Option(Choice, Generic[T]):
                     (Option,),
                     {"_opt_types": ((None, NullType), (None, opt_t))})
 
-    def __init__(self, val: T|NullType = Null):
+    def __init__(self, val: T|NullType = Null, key = None):
         super().__init__(val)
 
     def set(self, value: T|NullType = Null, key: Optional[str] = None):

tsrkit_types/struct.py

@@ -1,10 +1,11 @@
 from dataclasses import dataclass, fields
-from typing import Any, Tuple, Union
+from typing import Any, Tuple, Union, dataclass_transform
 from tsrkit_types.itf.codable import Codable
 from tsrkit_types.null import NullType
 from tsrkit_types.option import Option
 
 
+@dataclass_transform()
 def structure(_cls=None, *, frozen=False, **kwargs):
     """Extension of dataclass to support serialization and json operations. 
 
@@ -66,7 +67,6 @@ def structure(_cls=None, *, frozen=False, **kwargs):
                     init_data[field.name] = field.type.from_json(v)
             return cls(**init_data)
 
-
         new_cls.__init__ = __init__
 
         # Only overwrite if the method is not already defined

{tsrkit_types-0.1.8.dist-info → tsrkit_types-0.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tsrkit-types
-Version: 0.1.8
+Version: 0.1.9
 Summary: Performant Python Typings library for type-safe binary serialization, JSON encoding, and data validation with zero dependencies
 Author-email: chainscore-labs <hello@chainscore.finance>, prasad-kumkar <prasad@chainscore.finance>
 License-Expression: MIT
@@ -27,7 +27,7 @@ Classifier: Topic :: Utilities
 Classifier: Topic :: System :: Archiving
 Classifier: Topic :: Communications
 Classifier: Typing :: Typed
-Requires-Python: >=3.11
+Requires-Python: <3.13,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: dev

tsrkit_types-0.1.9.dist-info/RECORD

@@ -0,0 +1,21 @@
+tsrkit_types/__init__.py,sha256=5TTpyp57FCC9FKOXQ8XQl2Tnow9Re99jW3yepMl5ZOk,1900
+tsrkit_types/bits.py,sha256=33WLfuUYdzGscoc-E3InTYdbJRIDeixoe_pG0XAv71c,4213
+tsrkit_types/bool.py,sha256=Veu6KLIeiRFnIW1sbawJ0haF0veyaL-As5mBiypq-uE,1280
+tsrkit_types/bytearray.py,sha256=5uBK_5bHVxRAocfRHDojCTtS2ysUh-8bFdWglO-ZM48,1781
+tsrkit_types/bytes.py,sha256=hsUJu1YQoFI68RE4lhAPkNUppXGNFvL21NKKyIumUi8,3195
+tsrkit_types/bytes_common.py,sha256=bx1B3smZaT0Z5P_9nHJ-WCZQxH7XKAN1uakEWdqDous,4724
+tsrkit_types/choice.py,sha256=k0ZBvWEniP4ewc1W8BAbwaFffiauEUegQhTY6OPYZ0o,5299
+tsrkit_types/dictionary.py,sha256=M8kugpiwwi383kgq0JMJMgkNU-VlPdbbUYHWqFynEFc,5609
+tsrkit_types/enum.py,sha256=3MyLW15_ToQQdctJjcMY8Xb3OsS_Ad997OOEo8FjVeA,4256
+tsrkit_types/integers.py,sha256=zeJZ-Q3S74xx6D9BvGYP94zQhslH05lbTSb2rGfiVCk,9176
+tsrkit_types/null.py,sha256=vzobz4-xJrUeky8pzbg-Qmz4N6b7GsCNf8TafbstlgY,1372
+tsrkit_types/option.py,sha256=m6ltnfTQQDL1yh1PMo7pEElflrYp90Y0AHikP4ujXwI,1643
+tsrkit_types/sequences.py,sha256=KOT5-4mia5Lc0CMjIF7Yqe34Sei92ZQ2s6GaP13soUg,8090
+tsrkit_types/string.py,sha256=8rvg0BwvyhQnbMW3qornmBFTQHeTQFUfwD7OC0eVgcY,2575
+tsrkit_types/struct.py,sha256=qD_hIz0-7gAryhc79ARod-ylqSbjTiZLbXCmdLB4lmo,3540
+tsrkit_types/itf/codable.py,sha256=qZ_UsFl3gcpaeztbHcaxF4U3Km_PfPa7ZvW3z5gk_Gk,2894
+tsrkit_types-0.1.9.dist-info/licenses/LICENSE,sha256=TwnDvVCPwHadHWLUuY1sPx03XNw1jzh_ZmoDBNai9Uc,1072
+tsrkit_types-0.1.9.dist-info/METADATA,sha256=yhVuEqs6w0KwCfcnSpOJ7k2JX2HFvdUapqIy4m7WMy4,22902
+tsrkit_types-0.1.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tsrkit_types-0.1.9.dist-info/top_level.txt,sha256=pnVhnUsnZ_A0FIj1zHwDw3suMGrfMJwusp-4GPVY1CM,13
+tsrkit_types-0.1.9.dist-info/RECORD,,

tsrkit_types-0.1.8.dist-info/RECORD

@@ -1,21 +0,0 @@
-tsrkit_types/__init__.py,sha256=PlhqxNwjXaJU5vTIqJdLvC5BBfExLAoKQ57peNG2Opc,1900
-tsrkit_types/bits.py,sha256=33WLfuUYdzGscoc-E3InTYdbJRIDeixoe_pG0XAv71c,4213
-tsrkit_types/bool.py,sha256=Veu6KLIeiRFnIW1sbawJ0haF0veyaL-As5mBiypq-uE,1280
-tsrkit_types/bytearray.py,sha256=5uBK_5bHVxRAocfRHDojCTtS2ysUh-8bFdWglO-ZM48,1781
-tsrkit_types/bytes.py,sha256=tsyeItlI4LZPnkxFY-5_kgoDs04Zk_Xuan1erkG4Ff0,2863
-tsrkit_types/bytes_common.py,sha256=b1Zqh_NhkCX718QaZC52J3nEzKAi1Fe8E0nefWVwwmo,2301
-tsrkit_types/choice.py,sha256=OVHxIr2PcnaTpo5sAMjipCArc5oATNsyYkqZNRqU7bA,5253
-tsrkit_types/dictionary.py,sha256=GcUvaHC1VOEc3OzUVAH0id--ncLqTJ6ZRz-lucMNRdY,5618
-tsrkit_types/enum.py,sha256=3MyLW15_ToQQdctJjcMY8Xb3OsS_Ad997OOEo8FjVeA,4256
-tsrkit_types/integers.py,sha256=Xu9hjGQWW_NP08QIhKSvlxTeA3UmKsQC1A3NatgILQo,8867
-tsrkit_types/null.py,sha256=vzobz4-xJrUeky8pzbg-Qmz4N6b7GsCNf8TafbstlgY,1372
-tsrkit_types/option.py,sha256=xwtaAFN20GjaGqzYZAAo1fZqqUZnCYHdy2bjshhY620,1631
-tsrkit_types/sequences.py,sha256=KOT5-4mia5Lc0CMjIF7Yqe34Sei92ZQ2s6GaP13soUg,8090
-tsrkit_types/string.py,sha256=8rvg0BwvyhQnbMW3qornmBFTQHeTQFUfwD7OC0eVgcY,2575
-tsrkit_types/struct.py,sha256=GoXWFc1OqO9CXnxFS7Xkms7J-rtZe8h32LkAIBlzdSM,3497
-tsrkit_types/itf/codable.py,sha256=agx8YSVWGBeEiLrU9eqh3ZoeTgpJsmmIlW622xIKqPI,2810
-tsrkit_types-0.1.8.dist-info/licenses/LICENSE,sha256=TwnDvVCPwHadHWLUuY1sPx03XNw1jzh_ZmoDBNai9Uc,1072
-tsrkit_types-0.1.8.dist-info/METADATA,sha256=XcMJiwod5CkNHpwSSrMTOvRZxMMpv9FEDhi_AS7IYPU,22896
-tsrkit_types-0.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tsrkit_types-0.1.8.dist-info/top_level.txt,sha256=pnVhnUsnZ_A0FIj1zHwDw3suMGrfMJwusp-4GPVY1CM,13
-tsrkit_types-0.1.8.dist-info/RECORD,,