tsrkit-types 0.1.4__tar.gz → 0.1.9__tar.gz

{tsrkit_types-0.1.4 → tsrkit_types-0.1.9}/CHANGELOG.md

@@ -40,7 +40,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.1.4] - 2025-06-06
 
 ### Fixed
-- **Documentation**: Corrected release date in changelog from 2025-01-03 to 2025-06-06
+- **Bytes type**: Corrected the name of the Bytes type from `ByteArrayNUM` to `BytesNUM`
 
 ## [0.1.3] - 2025-06-06
 

{tsrkit_types-0.1.4 → tsrkit_types-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tsrkit-types
-Version: 0.1.4
+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
@@ -794,6 +794,20 @@ pytest -v
 pytest -m "not slow"
 ```
 
+### Build and Publish
+
+1. Build the package:
+
+```bash
+python3 -m build --wheel
+```
+
+2. Publish the wheels:
+
+```bash
+twine upload dist/*
+```
+
 ### Test Coverage
 
 View the test coverage report:

{tsrkit_types-0.1.4 → tsrkit_types-0.1.9}/README.md

@@ -753,6 +753,20 @@ pytest -v
 pytest -m "not slow"
 ```
 
+### Build and Publish
+
+1. Build the package:
+
+```bash
+python3 -m build --wheel
+```
+
+2. Publish the wheels:
+
+```bash
+twine upload dist/*
+```
+
 ### Test Coverage
 
 View the test coverage report:
@@ -775,4 +789,4 @@ Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for gui
 
 - **Python**: >= 3.11
 - **Runtime Dependencies**: None (zero dependencies!)
-- **Development Dependencies**: pytest and plugins (see `pyproject.toml`) 
+- **Development Dependencies**: pytest and plugins (see `pyproject.toml`) 

{tsrkit_types-0.1.4 → tsrkit_types-0.1.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsrkit-types"
-version = "0.1.4"
+version = "0.1.9"
 description = "Performant Python Typings library for type-safe binary serialization, JSON encoding, and data validation with zero dependencies"
 authors = [
     {name = "chainscore-labs", email = "hello@chainscore.finance"},
@@ -8,7 +8,7 @@ authors = [
 ]
 readme = "README.md"
 license = "MIT"
-requires-python = ">=3.11"
+requires-python = ">=3.11,<3.13"
 keywords = [
     "serialization", "binary", "encoding", "types", "codable", "json", 
     "validation", "data-types", "type-safety", "zero-copy", "protocol",

{tsrkit_types-0.1.4 → tsrkit_types-0.1.9}/tests/test_int.py

@@ -56,3 +56,22 @@ def test_static_type_checker():
 	# This is fine
 	DataStore(a=UInt[8](19), b=UInt[16](288))
 
+def test_int_sub():
+	a = UInt[8](100)
+	b = UInt[8](80)
+	assert a - b == UInt[8](20)
+	assert str(a - b) == 'U8(20)'
+
+def test_int_compare_with_int():
+	a = UInt[8](100)
+	assert a > 80
+	assert a < 120
+	assert a >= 100
+	assert a <= 100
+	assert a != 101
+	assert a == 100
+	assert a != 101
+
+def test_int_min_max():
+	assert min(UInt[8](100), UInt[8](80)) == UInt[8](80)
+	assert max(UInt[8](100), UInt[8](80)) == UInt[8](100)

{tsrkit_types-0.1.4 → tsrkit_types-0.1.9}/tests/test_struct.py

@@ -1,4 +1,5 @@
-from tsrkit_types.integers import Uint
+from typing import Literal
+from tsrkit_types.integers import Int, Uint
 from tsrkit_types.itf.codable import Codable
 from tsrkit_types.string import String
 from tsrkit_types.struct import struct, structure
@@ -57,6 +58,6 @@ def test_struct_inheritance():
         name: String 
         age: Uint[8] = field(metadata={"default": Uint[8](0)})
 
-    p = Person(name=String("John"), age=Uint[8](30))
+    p = Person(name=String("John"), age=Int[Literal[8]](30))
     assert isinstance(p, Codable)
-    assert isinstance(p, Person)
+    assert isinstance(p, Person)

{tsrkit_types-0.1.4 → tsrkit_types-0.1.9}/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-0.1.4 → tsrkit_types-0.1.9}/tsrkit_types/bytearray.py

@@ -28,10 +28,12 @@ class ByteArray(bytearray, Codable, BytesMixin):
         current_offset = offset
         _len, _inc_offset = Uint.decode_from(buffer, offset)
         current_offset += _inc_offset
+        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
     
     # ---------------------------------------------------------------------------- #
     #                               JSON Serialization                             #
     # ---------------------------------------------------------------------------- #
     # JSON methods inherited from BytesMixin
-    
+    

{tsrkit_types-0.1.4 → tsrkit_types-0.1.9}/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):
@@ -51,11 +52,27 @@ class Bytes(bytes, Codable, BytesMixin, metaclass=BytesCheckMeta):
     def decode_from(cls, buffer: Union[bytes, bytearray, memoryview], offset: int = 0) -> Tuple["Bytes", int]:
         current_offset = offset
         _len = cls._length
+
         if _len is None:
             _len, _inc_offset = Uint.decode_from(buffer, offset)
             current_offset += _inc_offset
-        return cls(buffer[current_offset:current_offset+_len]), current_offset + _len - offset
-    
+        
+        if len(buffer[current_offset:current_offset+_len]) < _len:
+            raise TypeError("Insufficient buffer")
+        
+        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                             #
     # ---------------------------------------------------------------------------- #
@@ -67,4 +84,4 @@ Bytes64 = Bytes[64]
 Bytes128 = Bytes[128]
 Bytes256 = Bytes[256]
 Bytes512 = Bytes[512]
-Bytes1024 = Bytes[1024]
+Bytes1024 = Bytes[1024]

tsrkit_types-0.1.9/tsrkit_types/bytes_common.py

@@ -0,0 +1,134 @@
+"""
+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."""
+    
+    @classmethod
+    def from_bits(cls, bits: list[bool], bit_order: str = "msb"):
+        """Convert a list of bits to bytes with specified bit order."""
+        # 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
+                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."""
+        # 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)])
+            return bits
+        else:
+            raise ValueError(f"Unknown bit_order: {bit_order}")
+    
+    def to_json(self):
+        """Convert bytes to hex string for JSON serialization."""
+        return self.hex()
+    
+    @classmethod
+    def from_json(cls, data: str):
+        """Create instance from hex string."""
+        data = data.replace("0x", "")
+        return cls(bytes.fromhex(data))
+    
+    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."""
+    if bit_order not in ("msb", "lsb"):
+        raise ValueError(f"Unknown bit_order: {bit_order}. Must be 'msb' or 'lsb'") 

{tsrkit_types-0.1.4 → tsrkit_types-0.1.9}/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))
@@ -68,6 +68,9 @@ class Choice(Codable):
     def unwrap(self) -> Any:
         return self._value
 
+    def get_key(self):
+        return self._choice_key
+
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}({self._value!r})"
 
@@ -95,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:
@@ -129,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-0.1.4 → tsrkit_types-0.1.9}/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-0.1.4 → tsrkit_types-0.1.9}/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
 
 
@@ -11,7 +22,7 @@ class IntCheckMeta(abc.ABCMeta):
         return isinstance(instance, int) and getattr(instance, "byte_size", 0) == cls.byte_size
 
 
-class Uint(int, Codable, metaclass=IntCheckMeta):
+class Int(int, Codable, metaclass=IntCheckMeta):
     """
     Unsigned integer type.
     
@@ -52,23 +63,44 @@ class Uint(int, Codable, metaclass=IntCheckMeta):
     # If the byte_size is set, the integer is fixed size.
     # Otherwise, the integer is General Integer (supports up to 2**64 - 1)
     byte_size: int = 0
+    signed = False
+    _bound = 1 << 64
+    
+    @classmethod
+    def __class_getitem__(cls, data: Optional[Union[int, tuple, bool]]):
+        """
+        Args:
+            data: either byte_size or (byte_size, signed)
+        """
+        if data == None:
+            size, signed = 0, False
+        # If we have a single value arg - wither byte_size or signed
+        elif not isinstance(data, tuple):
+            if isinstance(data, int):
+                size, signed = data, False
+            else: 
+                size, signed = 0, bool(data)
+        else:
+            size, signed = data 
 
-    def __class_getitem__(cls, size: int):
-        return type(f"U{size}" if size else "Int", (cls,), {"byte_size": size // 8})
+        return type(f"U{size}" if size else "Int", (cls,), {
+            "byte_size": size // 8, 
+            "signed": signed, 
+            "_bound": 1 << size if size > 0 else 1 << 64
+        })
 
     def __new__(cls, value: Any):
         value = int(value)
         if cls.byte_size > 0:
-            bits = 8 * cls.byte_size
-            min_v = 0
-            max_v = (1 << bits) - 1
-            if not (min_v <= value <= max_v):
-                raise ValueError(f"Fixed Int: {cls.__name__} out of range: {value!r} "
-                                f"not in [{min_v}, {max_v}]")
+            max_v = (cls._bound // 2 if cls.signed else cls._bound) - 1  
+            min_v = -1 * cls._bound // 2 if cls.signed else 0
         else:
-            if not 0 <= value < 2 ** 64:
-                raise ValueError(f"General Int: Value must be between 0 and 2**64 - 1, got {value}")
-
+            min_v = -1 * cls._bound // 2 if cls.signed else 0
+            max_v = (cls._bound // 2 if cls.signed else cls._bound) - 1  
+        
+        if not (min_v <= value <= max_v):
+                raise ValueError(f"Int: {cls.__name__} out of range: {value!r} "
+                                f"not in [{min_v}, {max_v}]")
         return super().__new__(cls, value)
 
     def __repr__(self):
@@ -105,11 +137,11 @@ class Uint(int, Codable, metaclass=IntCheckMeta):
     # ---------------------------------------------------------------------------- #
     #                                  JSON Serde                                  #
     # ---------------------------------------------------------------------------- #
-    def to_json(self) -> str:
+    def to_json(self) -> int:
         return int(self)
     
     @classmethod
-    def from_json(cls, json_str: str) -> "Uint":
+    def from_json(cls, json_str: str) -> "Int":
         return cls(int(json_str))
 
     # ---------------------------------------------------------------------------- #
@@ -118,20 +150,24 @@ class Uint(int, Codable, metaclass=IntCheckMeta):
     @staticmethod
     def l(x):
         return math.floor(Decimal(x).ln() / (Decimal(7) * Decimal(2).ln()))
-
+    
+    def to_unsigned(self) -> "Int":
+        if not self.signed: return self
+        return int(self) + (self._bound // 2)
 
     def encode_size(self) -> int:
         if self.byte_size > 0:
             return self.byte_size 
         else:
-            if self < 2**7:
+            value = self.to_unsigned()
+            if value < 2**7:
                 return 1
-            elif self < 2 ** (7 * 9):
+            elif value < 2 ** (7 * 9):
                 return 1 + self.l(self)
-            elif self < 2**64:
+            elif value < 2**64:
                 return 9
             else:
-                raise ValueError("Value too large for encoding. General Uint support up to 2**64 - 1")
+                raise ValueError("Value too large for encoding. General Int support up to 2**64 - 1")
 
     def encode_into(self, buffer: bytearray, offset: int = 0) -> int:
         if self.byte_size > 0:
@@ -206,7 +242,7 @@ class Uint(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))
@@ -214,7 +250,8 @@ class Uint(int, Codable, metaclass=IntCheckMeta):
             return cls(int("".join(str(int(b)) for b in reversed(bits)), 2))
 
 
-U8 = Uint[8]
-U16 = Uint[16]
-U32 = Uint[32]
-U64 = Uint[64]
+Uint = Int
+U8 = Int[8]
+U16 = Int[16]
+U32 = Int[32]
+U64 = Int[64]

{tsrkit_types-0.1.4 → tsrkit_types-0.1.9}/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-0.1.4 → tsrkit_types-0.1.9}/tsrkit_types/null.py

@@ -1,7 +1,7 @@
 from typing import Optional, Tuple, Union
+from tsrkit_types.itf.codable import Codable
 
-
-class NullType:
+class NullType(Codable):
     def __repr__(self):
         return "Null"
 
@@ -40,4 +40,4 @@ class NullType:
     
     
     
-Null = NullType()
+Null = NullType()

{tsrkit_types-0.1.4 → tsrkit_types-0.1.9}/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-0.1.4 → tsrkit_types-0.1.9}/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.4 → tsrkit_types-0.1.9}/tsrkit_types.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tsrkit-types
-Version: 0.1.4
+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
@@ -794,6 +794,20 @@ pytest -v
 pytest -m "not slow"
 ```
 
+### Build and Publish
+
+1. Build the package:
+
+```bash
+python3 -m build --wheel
+```
+
+2. Publish the wheels:
+
+```bash
+twine upload dist/*
+```
+
 ### Test Coverage
 
 View the test coverage report:

tsrkit_types-0.1.4/tsrkit_types/bytes_common.py

@@ -1,68 +0,0 @@
-"""
-Common functionality for Bytes and ByteArray types.
-"""
-
-from typing import Union
-
-
-class BytesMixin:
-    """Mixin providing common functionality for bytes-like types."""
-    
-    @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
-                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))
-
-    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":
-                bits.extend([bool((byte >> i) & 1) for i in range(8)])
-            else:
-                raise ValueError(f"Unknown bit_order: {bit_order}")
-        return bits
-    
-    def to_json(self):
-        """Convert bytes to hex string for JSON serialization."""
-        return self.hex()
-    
-    @classmethod
-    def from_json(cls, data: str):
-        """Create instance from hex string."""
-        data = data.replace("0x", "")
-        return cls(bytes.fromhex(data))
-    
-    def __str__(self):
-        return f"{self.__class__.__name__}({self.hex()})"
-
-
-def validate_bit_order(bit_order: str) -> None:
-    """Validate bit order parameter."""
-    if bit_order not in ("msb", "lsb"):
-        raise ValueError(f"Unknown bit_order: {bit_order}. Must be 'msb' or 'lsb'")