tsrkit-types 0.1.0__py3-none-any.whl

tsrkit_types/__init__.py

@@ -0,0 +1,76 @@
+# from jam.types.base.integers import (
+#     U8,
+#     U16,
+#     U32,
+#     U64,
+#     U128,
+#     U256,
+#     Int,
+# )
+# from jam.types.base.string import String
+# from jam.types.base.null import Null, Nullable
+# from jam.types.base.dictionary import Dictionary, decodable_dictionary
+# from jam.types.base.boolean import Boolean
+# from jam.types.base.bit import Bit
+# from jam.types.base.composite import Choice, Option, decodable_choice, decodable_option
+# from jam.types.base.sequences.array import Array, decodable_array
+# from jam.types.base.sequences.vector import Vector, decodable_vector
+# from jam.types.base.bytes.bytes import Bytes
+# # from jam.types.base.sequences.bytes import BitArray, decodable_bit_array, Byte
+# # from jam.types.base.bytes.byte_array import (
+# #     ByteArray8,
+# #     ByteArray16,
+# #     ByteArray32,
+# #     ByteArray64,
+# #     ByteArray96,
+# #     ByteArray128,
+# #     ByteArray144,
+# #     ByteArray256,
+# #     ByteArray784,
+# # )
+#
+# __all__ = [
+#     # Integer types
+#     "Int",
+#     "U8",
+#     "U16",
+#     "U32",
+#     "U64",
+#     "U128",
+#     "U256",
+#     # Choice and Null types
+#     "Choice",
+#     "Option",
+#     "Null",
+#     "Nullable",
+#     # Dictionary type
+#     "Dictionary",
+#     # Boolean and Bit types
+#     "Boolean",
+#     "Bit",
+#     # String type
+#     "String",
+#     # Sequence types
+#     # "Array",
+#     # "Vector",
+#     # # Byte types
+#     # "ByteArray8",
+#     # "ByteArray16",
+#     # "ByteArray32",
+#     # "ByteArray64",
+#     # "ByteArray96",
+#     # "ByteArray128",
+#     # "ByteArray144",
+#     # "ByteArray256",
+#     # "ByteArray784",
+#     # "BitArray",
+#     # "Byte",
+#     "Bytes",
+#     # Decodable types
+#     "decodable_array",
+#     "decodable_bit_array",
+#     "decodable_vector",
+#     "decodable_dictionary",
+#     "decodable_choice",
+#     "decodable_option",
+# ]

tsrkit_types/bits.py

@@ -0,0 +1,115 @@
+from typing import ClassVar, Sequence, Tuple, Union
+
+from tsrkit_types.bytes import Bytes
+from tsrkit_types.integers import Uint
+from tsrkit_types.sequences import Seq
+
+
+class Bits(Seq):
+	"""Bits[size, order]"""
+	_element_type = bool
+	_min_length: ClassVar[int] = 0
+	_max_length: ClassVar[int] = 2 ** 64
+	_order: ClassVar[str] = "msb"
+
+	def __class_getitem__(cls, params):
+		min_l, max_l, _bo = 0, 2**64, "msb"
+		if isinstance(params, tuple):
+			min_l, max_l, _bo = params[0], params[0], params[1]
+		else:
+			if isinstance(params, int):
+				min_l, max_l = params, params
+			else:
+				_bo = params
+
+		return type(cls.__class__.__name__, (cls,), {"_min_length": min_l, "_max_length": max_l, "_order": _bo})
+	
+
+	# ---------------------------------------------------------------------------- #
+	#                                  JSON Parse                                  #
+	# ---------------------------------------------------------------------------- #
+	
+	def to_json(self) -> str:
+		return Bytes.from_bits(self, bit_order=self._order).hex()
+	
+	@classmethod
+	def from_json(cls, json_str: str) -> "Bits":
+		return cls(Bytes.from_hex(json_str).to_bits(bit_order=cls._order))
+
+	# ---------------------------------------------------------------------------- #
+	#                                 Serialization                                #
+	# ---------------------------------------------------------------------------- #
+	
+	def encode_size(self) -> int:
+		# Calculate the number of bytes needed
+		bit_enc = 0
+		if self._length is None:
+			bit_enc = Uint(len(self)).encode_size()
+
+		return bit_enc + ((len(self) + 7) // 8)
+
+	def encode_into(
+		self, buffer: bytearray, offset: int = 0
+	) -> int:
+		total_size = self.encode_size()
+		self._check_buffer_size(buffer, total_size, offset)
+
+		# Initialize all bytes to 0
+		for i in range(0, total_size):
+			buffer[offset + i] = 0
+
+		if self._length is None:
+			# Encode the bit length first
+			offset += Uint(len(self)).encode_into(buffer, offset)
+		else:
+			# Ensure bit length is size of value
+			if len(self) != self._length:
+				raise ValueError("Bit sequence length mismatch")
+
+		if not all(
+			isinstance(bit, (bool, int)) and bit in (0, 1, True, False)
+			for bit in self
+		):
+			raise ValueError(f"Bit sequence must contain only 0s and 1s, got an sequence of {self}")
+
+		buffer[offset : offset + total_size] = Bytes.from_bits(
+			self, bit_order=self._order
+		)
+
+		return total_size
+
+	@classmethod
+	def decode_from(
+		cls,
+		buffer: Union[bytes, bytearray, memoryview],
+		offset: int = 0,
+	) -> Tuple[Sequence[bool], int]:
+		"""
+		Decode bit sequence from buffer.
+
+		Args:
+			buffer: Source buffer
+			offset: Starting offset
+			bit_length: Expected number of bits (required)
+
+		Returns:
+			Tuple of (decoded bit list, bytes read)
+
+		Raises:
+			DecodeError: If buffer too small or bit_length not specified
+		"""
+		_len = cls._length
+		if _len is None:
+			# Assume first byte is the bit length
+			_len, size = Uint.decode_from(buffer, offset)
+			offset += size
+
+		if _len == 0:
+			return [], 0
+
+		# Calculate required bytes
+		byte_count = (_len + 7) // 8
+		cls._check_buffer_size(buffer, byte_count, offset)
+
+		result = Bytes(buffer[offset : offset + byte_count]).to_bits(bit_order=cls._order)
+		return cls(result), byte_count

tsrkit_types/bool.py

@@ -0,0 +1,41 @@
+from typing import Tuple, Union
+from tsrkit_types.itf.codable import Codable
+
+
+class Bool(Codable):
+    _value: bool
+    def __init__(self, value: bool):
+        self._value = value
+
+    def __bool__(self):
+        return bool(self._value)
+    
+    # ---------------------------------------------------------------------------- #
+    #                                 Serialization                                #
+    # ---------------------------------------------------------------------------- #
+    
+    def encode_size(self) -> int:
+        return 1
+    
+    def encode_into(self, buffer: bytearray, offset: int = 0) -> int:
+        buffer[offset] = int(self._value)
+        return 1
+    
+    @classmethod
+    def decode_from(cls, buffer: Union[bytes, bytearray, memoryview], offset: int = 0) -> Tuple["Bool", int]:
+        return cls(bool(buffer[offset])), 1
+    
+    # ---------------------------------------------------------------------------- #
+    #                                  JSON Parse                                  #
+    # ---------------------------------------------------------------------------- #
+    
+    def to_json(self) -> str:
+        return "true" if self._value else "false"
+    
+    @classmethod
+    def from_json(cls, json_str: str) -> "Bool":
+        if json_str == "true":
+            return cls(True)
+        if json_str == "false":
+            return cls(False)
+        raise ValueError("Invalid JSON string for Bool")

tsrkit_types/bytes.py

@@ -0,0 +1,102 @@
+from typing import Tuple, Union, ClassVar, Self
+import base64
+
+from tsrkit_types.integers import Uint
+from tsrkit_types.itf.codable import Codable
+
+class Bytes(bytes, Codable):
+
+    _length: ClassVar[Union[None, int]] = None
+
+    def __class_getitem__(cls, params):
+        _len = None
+        name = cls.__class__.__name__
+        if params and params > 0:
+            _len = params
+            name = f"ByteArray{_len}"
+        return type(name, (cls,), {
+            "_length": _len,
+        })
+
+    def __str__(self):
+        return f"{self.__class__.__name__}({self.hex()})"
+
+    @classmethod
+    def from_bits(cls, bits: list[bool], bit_order = "msb") -> Self:
+        # 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}")
+            # noinspection PyUnreachableCode
+            byte_arr.append(val)
+        return cls(bytes(byte_arr))
+
+    def to_bits(self, bit_order="msb") -> list[bool]:
+        bits = []
+        for byte in self:
+            if bit_order == "msb":
+                bits.extend([(byte >> i) & 1 for i in reversed(range(8))])
+            elif bit_order == "lsb":
+                bits.extend([(byte >> i) & 1 for i in range(8)])
+            else:
+                raise ValueError(f"Unknown bit_order: {bit_order}")
+        return bits
+    
+    # ---------------------------------------------------------------------------- #
+    #                                 Serialization                                #
+    # ---------------------------------------------------------------------------- #
+    def encode_size(self) -> int:
+        if self._length is None:
+            return Uint(len(self)).encode_size() + len(self)
+        return self._length
+    
+    def encode_into(self, buf: bytearray, offset: int = 0) -> int:
+        current_offset = offset
+        _len = self._length
+        if _len is None:
+            _len = len(self)
+            current_offset += Uint(_len).encode_into(buf, current_offset)
+        buf[current_offset:current_offset+_len] = self
+        current_offset += _len
+        return current_offset - offset
+    
+    @classmethod
+    def decode_from(cls, buffer: Union[bytes, bytearray, memoryview], offset: int = 0) -> Tuple[Self, 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
+    
+    # ---------------------------------------------------------------------------- #
+    #                               JSON Serialization                             #
+    # ---------------------------------------------------------------------------- #
+    def to_json(self):
+        """Convert bytes to hex string for JSON serialization"""
+        return self.hex()
+    
+    @classmethod
+    def from_json(cls, data: str):
+        """Create Bytes instance from hex string"""
+        data = data.replace("0x", "")
+        return cls(bytes.fromhex(data))
+        

tsrkit_types/choice.py

@@ -0,0 +1,127 @@
+from typing import ClassVar, Optional, Union, Tuple, Any, get_origin
+from typing_extensions import get_args
+
+from tsrkit_types.integers import Uint
+from tsrkit_types.itf.codable import Codable
+
+ChoiceType = Tuple[Optional[str], type] | type
+
+class Choice(Codable):
+    """
+    Can either be defined as:
+        
+
+    Usage:
+        >>> dir_choice = Choice[T1, T2, ...](T1(XYZ))
+        -> makes _opt_types = (None, T1), (None, T2), ...
+
+        >>> dir_choice.set(T2(ABC))
+        -> changes the choice to T2(ABC)
+
+        >>> class NamedChoice(Choice):
+        >>>    type1: T1
+        >>>    type2: T2
+        >>>    type3: T2
+        -> makes _opt_types = (type1, T1), (type2, T2), ... 
+        >>> a = NamedChoice(T1(XYZ))
+        # If setting a choice with multiple types, the first type is the default, or give an optional key string
+        >>> b = NamedChoice(T2(ABC))
+        >>> b.to_json()
+        -> {"type2": "ABC"}
+        >>> c = NamedChoice(T2(ABC), key="type3")
+        >>> c.to_json()
+        -> {"type3": "ABC"}
+    """
+    _opt_types: ClassVar[Tuple[ChoiceType]]
+    _choice_key: Optional[str]
+    _value: Any
+
+    @property
+    def _choice_types(self) -> Tuple[type]:
+        return tuple(self._choice[1] for self._choice in self._opt_types)
+    
+    @property
+    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):
+        _opt_types = []
+        if isinstance(opt_t, type):
+            _opt_types.append((None, opt_t))
+        else:
+            for op in opt_t:
+                _opt_types.append((None, op))
+        name = f"Choice[{'/'.join(op[1].__class__.__name__ for op in _opt_types)}]"
+        return type(name,
+                    (Choice,),
+                    {"_opt_types": tuple(_opt_types)})
+    
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        ann = getattr(cls, "__annotations__", {})
+        if ann:
+            cls._opt_types = tuple((field, ann[field]) for field in ann)
+
+    def __init__(self, value: Any, key: Optional[str] = None) -> None:
+        super().__init__()
+        self.set(value, key)
+
+    def unwrap(self) -> Any:
+        return self._value
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self._value!r})"
+
+    def __eq__(self, other):
+        if isinstance(other, Choice):
+            return other._value == self._value
+        return other == self._value
+
+    def set(self, value: Any, key: Optional[str] = None):
+        if not isinstance(value, self._choice_types):
+            raise TypeError(f"{value!r} is not a {self._choice_types}")
+        
+        key = key or tuple(self._choice[0] for self._choice in self._opt_types if isinstance(value, self._choice[1]))[0]
+        if key not in self._choice_keys:
+            raise ValueError(f"Key {key!r} not in {self._choice_keys}")
+        
+        self._choice_key = key
+        self._value = value
+
+    # ---------------------------------------------------------------------------- #
+    #                                  JSON Serde                                  #
+    # ---------------------------------------------------------------------------- #
+
+    def to_json(self):
+        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":
+        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:
+                raise ValueError(f"Key {list(data.keys())[0]} not in {cls._opt_types}")
+            return cls(opt_type[1].from_json(list(data.values())[0]), key=opt_type[0])
+        return cls(cls._opt_types[0][1].from_json(data), key=cls._opt_types[0][0])
+
+    # ---------------------------------------------------------------------------- #
+    #                                 Serialization                                #
+    # ---------------------------------------------------------------------------- #
+
+    def encode_size(self) -> int:
+        return Uint(len(self._opt_types)).encode_size() + self._value.encode_size()
+
+    def encode_into(self, buf: bytearray, offset: int = 0) -> int:
+        current_offset = offset
+        current_offset += Uint(self._choice_types.index(type(self._value))).encode_into(buf, current_offset)
+        current_offset += self._value.encode_into(buf, current_offset)
+        return current_offset - offset
+
+    @classmethod
+    def decode_from(
+        cls, buffer: Union[bytes, bytearray, memoryview], offset: int = 0
+    ) -> Tuple[Any, int]:
+        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

tsrkit_types/dictionary.py

@@ -0,0 +1,145 @@
+import abc
+from typing import (
+    Generic,
+    Mapping,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    Dict,
+    Any,
+    Sequence,
+)
+
+from tsrkit_types.integers import Uint
+from tsrkit_types.itf.codable import Codable
+
+K = TypeVar("K", bound=Codable)
+V = TypeVar("V", bound=Codable)
+
+
+class DictCheckMeta(abc.ABCMeta):
+    """Meta class to check if the instance is a dictionary with the same key and value types"""
+    def __instancecheck__(cls, instance):
+        _matches_key_type = getattr(cls, "_key_type", None) == getattr(instance, "_key_type", None)
+        _matches_value_type = getattr(cls, "_value_type", None) == getattr(instance, "_value_type", None)
+        return isinstance(instance, dict) and _matches_key_type and _matches_value_type
+
+
+class Dictionary(dict, Codable, Generic[K, V], metaclass=DictCheckMeta):
+    """
+    Dictionary implementation that supports codec operations.
+
+    A dictionary that maps keys to values, providing both standard
+    dictionary operations and codec functionality for serialization/deserialization.
+
+    Examples:
+        >>> from tsrkit_types.string import String
+        >>> from tsrkit_types.integers import Uint
+        >>> d = Dictionary({String("key"): Uint(42)})
+        >>> d[String("key")]
+        Uint(42)
+        >>> encoded = d.encode()
+        >>> decoded, _ = d.decode_from(encoded)
+        >>> decoded == d
+        True
+    """
+
+    _key_type: Type[K]
+    _value_type: Type[V]
+
+    _key_name: Optional[str]
+    _value_name: Optional[str]
+
+    def __class_getitem__(cls, params):
+        if len(params) >= 2:
+            return type(cls.__name__, (cls,), {
+                "_key_type": params[0],
+                "_value_type": params[1],
+                "_key_name": params[2] if len(params) == 4 else None,
+                "_value_name": params[3] if len(params) == 4 else None,
+            })
+        else:
+            raise ValueError("Dictionary must be initialized with types as such - Dictionary[K, V, key_name(optional), value_name(optional)]")
+
+    def __init__(self, initial: Optional[Mapping[K, V]] = None):
+        self.update(initial or {})
+
+    def _validate(self, key: K, value: V):
+        if not isinstance(key, self._key_type):
+            raise TypeError(f"Dictionary keys must be {self._key_type} but got {type(key)}")
+        if not isinstance(value, self._value_type):
+            raise TypeError(f"Dictionary values must be {self._value_type} but got {type(value)}")
+
+    def __setitem__(self, key: K, value: V) -> None:
+        """Set value for key."""
+        self._validate(key, value)
+        super().__setitem__(key, value)
+
+    def __repr__(self) -> str:
+        """Get string representation."""
+        items = [f"{k!r}: {v!r}" for k, v in self.items()]
+        return f"Dictionary({{{', '.join(items)}}})"
+    
+    def update(self, other: Mapping[K, V]) -> None:
+        for key, value in other.items():
+            self._validate(key, value)
+        super().update(other)
+
+    # ---------------------------------------------------------------------------- #
+    #                                  JSON Serde                                  #
+    # ---------------------------------------------------------------------------- #
+
+    def to_json(self) -> Dict[Any, Any]:
+        """Convert to JSON representation."""
+        return {k.to_json(): v.to_json() for k, v in self.items()}
+
+    @classmethod
+    def from_json(cls: Type["Dictionary[K, V]"], data: Sequence[Any]) -> "Dictionary[K, V]":
+        """Create instance from JSON representation."""
+        if not isinstance(data, dict):
+            _value = cls({})
+            for val in data:
+                _value[cls.key_type.from_json(val[cls.key_name])] = cls.value_type.from_json(val[cls.value_name])
+            return _value
+        else:
+            return cls(
+                {
+                    cls._key_type.from_json(k): cls._value_type.from_json(v)
+                    for k, v in data.items()
+                }
+            )
+
+    # ---------------------------------------------------------------------------- #
+    #                                  Serialization                               #
+    # ---------------------------------------------------------------------------- #
+
+    def encode_size(self) -> int:
+        total_size = 0
+        total_size += Uint(len(self)).encode_size()
+        for k, v in self.items():
+            total_size += k.encode_size() + v.encode_size()
+        return total_size
+    
+    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()):
+            current_offset += k.encode_into(buffer, current_offset)
+            current_offset += v.encode_into(buffer, current_offset)
+        return current_offset - offset
+
+    @classmethod
+    def decode_from(cls, buffer: Union[bytes, bytearray, memoryview], offset: int = 0) -> Tuple["Dictionary[K, V]", int]:
+        current_offset = offset
+        dict_len, size = Uint.decode_from(buffer, offset)
+        current_offset += size
+        res = cls()
+        for _ in range(dict_len):
+            key, size = cls._key_type.decode_from(buffer, current_offset)
+            current_offset += size
+            value, size = cls._value_type.decode_from(buffer, current_offset)
+            current_offset += size
+            res[key] = value
+        return res, current_offset - offset