feat: check_validation

Author: GuangChen2333

README.md

@@ -73,10 +73,32 @@ And you will get:
 You can define your own data types by simply inheriting the `BaseType` class:
 
 ```python
+from typing import Tuple, Type
 from structovo import BaseType, Endianness
 
 
 class MyDataType(BaseType):
-    def encode(self, endianness: Endianness) -> bytes:
+    def check_validation(self) -> Tuple[bool, Type]:
+        # Implement the validation of whether the self.value is valid.
         return ...
+
+    def encode(self, endianness: Endianness) -> bytes:
+        # Implement the operation of converting self.value to bytes.
+        return ...    
+```
+
+Like this: 
+
+```python
+from typing import Tuple, Type
+from structovo import BaseType, Endianness
+
+
+class BYTE(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = isinstance(self.value, bytes)
+        return result, bytes
+
+    def encode(self, endianness: Endianness) -> bytes:
+        return self._pack('c', endianness)
 ```

src/structovo/_packet.py

@@ -1,5 +1,5 @@
 from typing import TypeVar, Optional
-from ._types import BaseType, FixedString
+from ._types import BaseType
 from ._enums import Endianness
 
 T = TypeVar('T', bound='Pack')
@@ -14,22 +14,21 @@ def build(cls, endianness: Optional[Endianness] = Endianness.NATIVE) -> bytes:
         result_list = []
 
         for key, type_class in anns.items():
-            if not issubclass(type_class, BaseType) and not type_class is bytes:
-                raise ValueError(f"{type_class} is not an instance of bytes or structovo.BaseType")
+            try:
+                if not issubclass(type_class, BaseType) and not type_class is bytes:
+                    raise ValueError(f"{type_class} is not an instance of bytes or structovo.BaseType")
 
-            if type_class is bytes:
-                result_list.append(data.get(key))
-                continue
+                if type_class is bytes:
+                    result_list.append(data.get(key))
+                    continue
 
-            elif type_class is FixedString:
-                try:
-                    value: FixedString = FixedString(data[key][0], data[key][1])
-                except IndexError:
-                    raise ValueError('Using x: FixedString = (value: bytes, length: int)')
+                else:
+                    value: BaseType = type_class(data.get(key))
 
-            else:
-                value: BaseType = type_class(data.get(key))
+                value.raise_if_invalid()
+                result_list.append(value.encode(endianness))
+            except Exception as e:
+                raise ValueError(f"Key {key} raised that {e}, and now it is a {type(data.get(key))}.")
 
-            result_list.append(value.encode(endianness))
 
         return b''.join(result_list)

src/structovo/_types.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Tuple, Optional, Type
 from abc import ABC, abstractmethod
 from struct import pack
 
@@ -14,6 +14,11 @@ def __new__(cls, value: Any):
     def _pack(self, fmt: str, endianness: Endianness) -> bytes:
         return pack(f'{endianness.value}{fmt}', self.value)
 
+    def raise_if_invalid(self):
+        result, real = self.check_validation()
+        if not result:
+            raise ValueError(f"Invalid value type, it must be a {real}")
+
     @property
     def value(self):
         return self._value
@@ -22,97 +27,178 @@ def value(self):
     def encode(self, endianness: Endianness) -> bytes:
         pass
 
+    @abstractmethod
+    def check_validation(self) -> Tuple[bool, Type]:
+        pass
+
 
 class PADDING(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = self.value is None or isinstance(self.value, int)
+        return result, Optional[int]
+
     def encode(self, endianness: Endianness) -> bytes:
         return b'\x00' * (self.value if self.value else 1)
 
 
 class BYTE(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = isinstance(self.value, bytes)
+        return result, bytes
+
     def encode(self, endianness: Endianness) -> bytes:
         return self._pack('c', endianness)
 
 
 class CHAR(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = isinstance(self.value, int)
+        return result, int
+
     def encode(self, endianness: Endianness) -> bytes:
         return self._pack('b', endianness)
 
 
 class UCHAR(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = isinstance(self.value, int)
+        return result, int
+
     def encode(self, endianness: Endianness) -> bytes:
         return self._pack('B', endianness)
 
 
 class BOOL(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = isinstance(self.value, bool)
+        return result, bool
+
     def encode(self, endianness: Endianness) -> bytes:
         return self._pack('?', endianness)
 
 
 class SHORT(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = isinstance(self.value, int)
+        return result, int
+
     def encode(self, endianness: Endianness) -> bytes:
         return self._pack('h', endianness)
 
 
 class USHORT(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = isinstance(self.value, int)
+        return result, int
+
     def encode(self, endianness: Endianness) -> bytes:
         return self._pack('H', endianness)
 
 
 class INT(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = isinstance(self.value, int)
+        return result, int
+
     def encode(self, endianness: Endianness) -> bytes:
         return self._pack('i', endianness)
 
 
 class UINT(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = isinstance(self.value, int)
+        return result, int
+
     def encode(self, endianness: Endianness) -> bytes:
         return self._pack('I', endianness)
 
 
 class LONG(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = isinstance(self.value, int)
+        return result, int
+
     def encode(self, endianness: Endianness) -> bytes:
         return self._pack('l', endianness)
 
 
 class ULONG(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = isinstance(self.value, int)
+        return result, int
+
     def encode(self, endianness: Endianness) -> bytes:
         return self._pack('L', endianness)
 
 
 class LONGLONG(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = isinstance(self.value, int)
+        return result, int
+
     def encode(self, endianness: Endianness) -> bytes:
         return self._pack('q', endianness)
 
 
 class ULONGLONG(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = isinstance(self.value, int)
+        return result, int
+
     def encode(self, endianness: Endianness) -> bytes:
         return self._pack('Q', endianness)
 
 
 class SSIZET(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = isinstance(self.value, int)
+        return result, int
+
     def encode(self, endianness: Endianness) -> bytes:
         return self._pack('n', endianness)
 
 
 class SIZET(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = isinstance(self.value, int)
+        return result, int
+
     def encode(self, endianness: Endianness) -> bytes:
         return self._pack('N', endianness)
 
 
 class FLOAT(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = isinstance(self.value, float)
+        return result, float
+
     def encode(self, endianness: Endianness) -> bytes:
         return self._pack('f', endianness)
 
 
 class DOUBLE(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = isinstance(self.value, float)
+        return result, float
+
     def encode(self, endianness: Endianness) -> bytes:
         return self._pack('d', endianness)
 
 
 class FixedString(BaseType):
-    def __new__(cls, value: bytes, length: int):
+    def check_validation(self):
+        return (
+                not isinstance(self.value, tuple)
+                or not isinstance(self.value[0], bytes)
+                or not isinstance(self.value[1], int)
+        ), Tuple[bytes, int]
+
+    def __new__(cls, value: Tuple[bytes, int]):
         instance = super().__new__(cls, value)
-        instance._value = value
-        instance._length = length
+
+        instance._value = value[0]
+        instance._length = value[1]
+
         return instance
 
     @property
@@ -124,6 +210,10 @@ def encode(self, endianness: Endianness) -> bytes:
 
 
 class LengthPrefixedString(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = isinstance(self.value, bytes)
+        return result, bytes
+
     def encode(self, endianness: Endianness) -> bytes:
         length = len(self.value)
         if length > 255:
@@ -132,10 +222,18 @@ def encode(self, endianness: Endianness) -> bytes:
 
 
 class BINARY16(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = isinstance(self.value, float)
+        return result, float
+
     def encode(self, endianness: Endianness) -> bytes:
         return self._pack('e', endianness)
 
 
 class UnsignedPointer(BaseType):
+    def check_validation(self) -> Tuple[bool, Type]:
+        result = isinstance(self.value, int)
+        return result, int
+
     def encode(self, endianness: Endianness) -> bytes:
         return self._pack('P', endianness)