tsrkit-types 0.1.0__py3-none-any.whl

tsrkit_types/string.py

@@ -0,0 +1,66 @@
+from typing import Union, Tuple
+
+from tsrkit_types.integers import Uint
+from tsrkit_types.itf.codable import Codable
+
+
+class String(str, Codable):
+    """
+    UTF-8 encoded string type that implements the Codable interface.
+
+    Examples:
+        >>> s = String("Hello")
+        >>> str(s)
+        'Hello'
+        >>> len(s)
+        5
+        >>> s.encode()
+        b'\\x05Hello'  # Length prefix followed by UTF-8 bytes
+
+    Note:
+        String length is measured in UTF-16 code units, which means some Unicode
+        characters (like emojis) may count as 2 units. This matches Python's
+        string length behavior.
+    """
+
+    # ---------------------------------------------------------------------------- #
+    #                                 Serialization                                #
+    # ---------------------------------------------------------------------------- #
+    def encode(self) -> bytes:
+        buffer = bytearray(self.encode_size())
+        self.encode_into(buffer)
+        return buffer
+    
+    def encode_size(self) -> int:
+        utf8_bytes = str(self).encode('utf-8')
+        return Uint(len(utf8_bytes)).encode_size() + len(utf8_bytes)
+    
+    def encode_into(self, buffer: bytearray, offset: int = 0) -> int:
+        current_offset = offset
+        utf8_bytes = str(self).encode('utf-8')
+        current_offset += Uint(len(utf8_bytes)).encode_into(buffer, current_offset)
+        buffer[current_offset:current_offset + len(utf8_bytes)] = utf8_bytes
+        return current_offset + len(utf8_bytes) - offset
+    
+    @classmethod
+    def decode_from(cls, buffer: Union[bytes, bytearray, memoryview], offset: int = 0) -> Tuple["String", int]:
+        current_offset = offset
+        byte_len, size = Uint.decode_from(buffer, current_offset)
+        current_offset += size
+        utf8_bytes = buffer[current_offset:current_offset + byte_len]
+        return cls(utf8_bytes.decode('utf-8')), current_offset + byte_len - offset
+    
+    @classmethod
+    def decode(cls, buffer: Union[bytes, bytearray, memoryview], offset: int = 0) -> Tuple["String", int]:
+        value, bytes_read = cls.decode_from(buffer, offset)
+        return value
+    
+    # ---------------------------------------------------------------------------- #
+    #                                  JSON Serde                                  #
+    # ---------------------------------------------------------------------------- #
+    def to_json(self) -> str:
+        return self
+    
+    @classmethod
+    def from_json(cls, data: str) -> "String":
+        return cls(data)

tsrkit_types/struct.py

@@ -0,0 +1,82 @@
+from dataclasses import dataclass, fields
+from typing import Any, Tuple, Union
+from tsrkit_types.itf.codable import Codable
+
+
+def struct(_cls=None, *, frozen=False, **kwargs):
+    """Extension of dataclass to support serialization and json operations. 
+
+    Usage:
+        >>> @struct
+        >>> class Person:
+        >>>     name: String = field(metadata={"name": "first_name"})
+        >>>     age: Uint[8] = field(metadata={"default": 0})
+
+    """
+    def wrap(cls):
+        new_cls = dataclass(cls, frozen=frozen, **kwargs)
+
+        orig_init = new_cls.__init__
+
+        def __init__(self, *args, **kwargs):
+            for field in fields(self):
+                # If the field is not found, but has a default, set it
+                if field.name not in kwargs and field.metadata.get("default") is not None:
+                    kwargs[field.name] = field.metadata.get("default")
+            orig_init(self, *args, **kwargs)
+
+        def encode_size(self) -> int:
+            return sum(getattr(self, field.name).encode_size() for field in fields(self))
+
+        def encode_into(self, buffer: bytes, offset = 0) -> int:
+            current_offset = offset
+            for field in fields(self):
+                item = getattr(self, field.name)
+                size = item.encode_into(buffer, current_offset)
+                current_offset += size
+
+            return current_offset - offset
+            
+        @classmethod
+        def decode_from(cls, buffer: Union[bytes, bytearray, memoryview], offset: int = 0) -> Tuple[Any, int]:
+            current_offset = offset
+            decoded_values = {}
+            for field in fields(cls): 
+                field_type = field.type
+                value, size = field_type.decode_from(buffer, current_offset)
+                decoded_values[field.name] = value
+                current_offset += size
+            instance = cls(**decoded_values)
+            return instance, current_offset - offset
+        
+        def to_json(self) -> dict:
+            return {field.metadata.get("name", field.name): getattr(self, field.name).to_json() for field in fields(self)}
+        
+        @classmethod
+        def from_json(cls, data: dict) -> Any:
+            init_data = {}
+            for field in fields(cls):
+                k = field.metadata.get("name", field.name)
+                v = data.get(k)
+                if v is None:
+                    if field.metadata.get("default") is not None:
+                        init_data[field.name] = field.metadata.get("default")
+                    else:
+                        raise ValueError(f"Field {k} not found in {cls}")
+                else:
+                    init_data[field.name] = field.type.from_json(v)
+            return cls(**init_data)
+
+
+        new_cls.__init__ = __init__
+        new_cls.encode_size = encode_size
+        new_cls.decode_from = decode_from
+        new_cls.encode_into = encode_into
+        new_cls.to_json = to_json
+        new_cls.from_json = from_json
+
+        new_cls = type(new_cls.__name__, (Codable, new_cls), dict(new_cls.__dict__))
+
+        return new_cls
+
+    return wrap if _cls is None else wrap(_cls)