structo 0.0.10__py3-none-any.whl

structo/__init__.py

@@ -0,0 +1,44 @@
+"""
+Structify
+"""
+
+__version__ = "0.0.10"
+
+from .interfaces import Serializer, Serializable
+from .serialise import get_serializer
+from .objects import SerializableObject, PackedInt, PackedInts
+from .serializers import (
+    uint64_BE,
+    uint64_LE,
+    uint64,
+    uint32_BE,
+    uint32_LE,
+    uint32,
+    uint16_BE,
+    uint16_LE,
+    uint16,
+    uint8,
+    int64_BE,
+    int64_LE,
+    int64,
+    int32_BE,
+    int32_LE,
+    int32,
+    int16_BE,
+    int16_LE,
+    int16,
+    int8,
+    float64_BE,
+    float64_LE,
+    float64,
+    float32_BE,
+    float32_LE,
+    float32,
+    Array,
+    Buffer,
+    List,
+    String,
+    Blob,
+    Literal,
+    Optional,
+)

structo/interfaces.py

@@ -0,0 +1,46 @@
+import io
+import typing as t
+
+
+class Serializable:
+    @classmethod
+    def serializer(cls) -> Serializer[t.Self]: ...
+
+    @classmethod
+    def sizeof(cls) -> int | None:
+        return cls.serializer().sizeof()
+
+    def write(self, f: t.IO[bytes]):
+        return self.serializer().write(f, self)
+
+    @classmethod
+    def read(cls, f: t.IO[bytes]) -> t.Self:
+        return cls.serializer().read(f)
+
+    def to_bytes(self) -> bytes:
+        return self.serializer().to_bytes(self)
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> t.Self:
+        return cls.serializer().from_bytes(data)
+
+
+class Serializer[T]:
+    def sizeof(self) -> int | None:
+        return None
+
+    def write(self, f: t.IO[bytes], value: T):
+        raise NotImplementedError(f"{type(self).__name__} can't be serialized")
+
+    def read(self, f: t.IO[bytes]) -> T:
+        raise NotImplementedError(f"{type(self).__name__} can't be deserialized")
+
+    def to_bytes(self, value: T) -> bytes:
+        buf = io.BytesIO()
+        self.write(buf, value)
+        buf.seek(0)
+        return buf.getvalue()
+
+    def from_bytes(self, data: bytes) -> T:
+        buf = io.BytesIO(data)
+        return self.read(buf)

structo/objects/__init__.py

@@ -0,0 +1,2 @@
+from .packed import PackedInt, PackedInts
+from .serializable_object import SerializableObject

structo/objects/packed.py

@@ -0,0 +1,50 @@
+from ..interfaces import Serializable, Serializer
+
+import typing as t
+from dataclasses import dataclass
+import annotationlib
+
+
+class PackedInt:
+    bits: int
+
+    def __init__(self, *, bits: int) -> None:
+        self.bits = bits
+
+
+class PackedIntsMeta(type):
+    def __new__(cls, name, bases, dct):
+        new_class = t.cast(type, super().__new__(cls, name, bases, dct))
+        if name == "PackedInts":
+            return new_class
+
+        annotate = annotationlib.get_annotate_from_class_namespace(dct)
+        assert annotate, f"Annotations not found for {name}"
+
+        annotations = annotate(annotationlib.Format.VALUE_WITH_FAKE_GLOBALS)
+
+        bits: dict[str, int] = {}
+        for key, value in annotations.items():
+            err_msg = f"expected Annotated[int, PackedInt(...)] on {name}.{key}"
+            assert t.get_origin(value) is t.Annotated, err_msg
+
+            ints = [arg for arg in t.get_args(value) if isinstance(arg, PackedInt)]
+            assert len(ints) <= 1, err_msg
+            assert len(ints) == 1, err_msg
+            bits[key] = ints[0].bits
+
+        obj = t.cast(PackedInts, dataclass(new_class))
+        obj._bits = bits
+        return obj
+
+
+# This is very messed up since we
+@t.dataclass_transform()
+class PackedInts(Serializable, metaclass=PackedIntsMeta):
+    _bits: dict[str, int]
+
+    @classmethod
+    def serializer(cls) -> Serializer[t.Self]:
+        from ..serializers import PackedIntSerializer
+
+        return PackedIntSerializer(cls)

structo/objects/serializable_object.py

@@ -0,0 +1,37 @@
+import annotationlib
+import typing as t
+from dataclasses import dataclass
+
+from ..interfaces import Serializable, Serializer
+from ..serialise import get_serializer
+
+
+class SerializableObjectMeta(type):
+    def __new__(cls, name, bases, dct):
+        new_class = t.cast(type, super().__new__(cls, name, bases, dct))
+        if name == "SerializableObject":
+            return new_class
+
+        annotate = annotationlib.get_annotate_from_class_namespace(dct)
+
+        assert annotate, "No annotations method available"
+        annotations = annotate(annotationlib.Format.VALUE_WITH_FAKE_GLOBALS)
+        
+        fields: dict[str, Serializer] = {}
+        for key, annotation in annotations.items():
+            try:
+                fields[key] = get_serializer(annotation)
+            except Exception as e:
+                raise ValueError(f"Invalid attribute defintion for {name}.{key}") from e
+
+        return t.cast(SerializableObject, dataclass(new_class))
+
+
+# This is very messed up since we
+@t.dataclass_transform()
+class SerializableObject(Serializable, metaclass=SerializableObjectMeta):
+    @classmethod
+    def serializer(cls) -> Serializer[t.Self]:
+        from ..serializers import ObjectSerializer
+
+        return ObjectSerializer(cls)

structo/serialise.py

@@ -0,0 +1,46 @@
+import typing as t
+from .interfaces import Serializer, Serializable
+
+
+def to_serializer[T](format: type[T] | Serializer[T]) -> Serializer[T]:
+    if isinstance(format, Serializer):
+        return format
+
+    if isinstance(format, type) and issubclass(format, Serializable):
+        return format.serializer()
+
+    raise AssertionError(f"Invalid value_type: {format}")
+
+
+def get_serializer(format: type | Serializer) -> Serializer:
+    if t.get_origin(format) is t.Annotated:
+        args = t.get_args(format)
+        serializers = [arg for arg in args if isinstance(arg, Serializer)]
+        assert len(serializers) != 0, f"No serializers for {format} found"
+        assert len(serializers) == 1, f"More than one serializers for {format} found"
+        serializer = serializers[0]
+
+        return serializer
+
+    if isinstance(format, type) and issubclass(format, Serializable):
+        return format.serializer()
+
+    # Nicely formatted errors:
+    if format == int:
+        raise ValueError(
+            f"No serializer for int, you need to use structo.int32, structo.int32 or similar instead"
+        )
+    if format == float:
+        raise ValueError(
+            f"No serializer for float, you need to use structo.float32 or structo.float64 instead"
+        )
+    if format == bytes:
+        raise ValueError(
+            f"No serializer for bytes, you need to use structo.Buffer or structo.Blob instead"
+        )
+    if format == list:
+        raise ValueError(
+            f"No serializer for list, you need to use structo.List or structo.Array instead"
+        )
+
+    raise NotImplementedError(f"No serializer found for {format}")

structo/serializers/__init__.py

@@ -0,0 +1,37 @@
+from .numbers import (
+    uint64_BE,
+    uint64_LE,
+    uint64,
+    uint32_BE,
+    uint32_LE,
+    uint32,
+    uint16_BE,
+    uint16_LE,
+    uint16,
+    uint8,
+    int64_BE,
+    int64_LE,
+    int64,
+    int32_BE,
+    int32_LE,
+    int32,
+    int16_BE,
+    int16_LE,
+    int16,
+    int8,
+    float64_BE,
+    float64_LE,
+    float64,
+    float32_BE,
+    float32_LE,
+    float32,
+)
+from .buffer import Buffer
+from .array import Array
+from .blob import Blob
+from .list import List
+from .string import String
+from .literal import Literal
+from .optional import Optional
+from .object import ObjectSerializer
+from .packed import PackedIntSerializer

structo/serializers/array.py

@@ -0,0 +1,34 @@
+from ..serialise import to_serializer
+from ..interfaces import Serializer
+
+
+class Array[T](Serializer[list[T]]):
+    _length: int
+    _value_type: Serializer[T]
+
+    def __init__(self, value: Serializer[T] | type[T], length: int) -> None:
+        assert length > 0, "Array must be longer than 0"
+        self._length = length
+        self._value_type = to_serializer(value)
+
+    def write(self, f, value):
+        assert (
+            len(value) == self._length
+        ), f"expected array with {self._length} length, receieved {len(value)}"
+
+        for item in value:
+            self._value_type.write(f, item)
+
+    def read(self, f):
+        items = []
+        for _ in range(self._length):
+            items.append(self._value_type.read(f))
+
+        return items
+
+    def sizeof(self):
+        element_length = self._value_type.sizeof()
+        if element_length is None:
+            return None
+        else:
+            return element_length * self._length

structo/serializers/blob.py

@@ -0,0 +1,20 @@
+from .numbers import uint32_LE
+from ..interfaces import Serializer
+
+
+class Blob(Serializer[bytes]):
+    "A set of arbitrary bytes, prefixed with it's length"
+
+    _length_type: Serializer[int]
+
+    def __init__(self, length_type: Serializer[int] | None = None) -> None:
+        self._length_type = length_type or uint32_LE
+
+    def write(self, f, value):
+        self._length_type.write(f, len(value))
+        f.write(value)
+
+    def read(self, f):
+        length = self._length_type.read(f)
+        data = f.read(length)
+        return data

structo/serializers/buffer.py

@@ -0,0 +1,21 @@
+from ..interfaces import Serializer
+
+
+class Buffer(Serializer[bytes]):
+    _length: int
+
+    def __init__(self, length: int) -> None:
+        self._length = length
+
+    def write(self, f, value):
+        assert (
+            len(value) == self._length
+        ), f"expected data with length {self._length}, received {len(value)}"
+        f.write(value)
+
+    def read(self, f):
+        data = f.read(self._length)
+        return data
+
+    def sizeof(self):
+        return self._length

structo/serializers/list.py

@@ -0,0 +1,29 @@
+from .numbers import uint32_LE
+from ..serialise import to_serializer
+from ..interfaces import Serializer
+
+
+class List[T](Serializer[list[T]]):
+    "A list of items, prefixed with it's length"
+
+    _length_type: Serializer[int]
+    _value_type: Serializer
+
+    def __init__(self, value: Serializer[T] | type[T], length: Serializer[int] | None = None) -> None:
+        self._length_type = length or uint32_LE
+        self._value_type = to_serializer(value)
+
+    def write(self, f, value):
+        length = len(value)
+        self._length_type.write(f, length)
+        for item in value:
+            self._value_type.write(f, item)
+
+    def read(self, f):
+        length = self._length_type.read(f)
+        values = []
+        for _ in range(length):
+            value = self._value_type.read(f)
+            values.append(value)
+
+        return values

structo/serializers/literal.py

@@ -0,0 +1,30 @@
+from ..interfaces import Serializer
+
+
+class Literal(Serializer[bytes]):
+    _values: list[bytes]
+    _length: int
+
+    def __init__(self, *values: bytes) -> None:
+        assert len(values) > 0, "foo"
+        length = len(values[0])
+
+        for value in values:
+            assert (
+                len(value) == length
+            ), f"All values in structo.Literal have to be the same length, expected {value} to be length {length}"
+
+        self._length = length
+        self._values = list(values)
+
+    def write(self, f, value):
+        assert value in self._values, f"{value} not in {b", ".join(self._values)}"
+        f.write(value)
+
+    def read(self, f):
+        value = f.read(self._length)
+        assert value in self._values, f"{value} not in {b", ".join(self._values)}"
+        return value
+
+    def sizeof(self):
+        return self._length

structo/serializers/numbers.py

@@ -0,0 +1,100 @@
+import io
+import struct
+from ..interfaces import Serializer
+
+
+def struct_serializer(sformat: str, bytes: int) -> Serializer:
+    class StructSerializer(Serializer):
+        def sizeof(self):
+            return bytes
+
+        def write(self, f, value):
+            data = struct.pack(sformat, value)
+            return f.write(data)
+
+        def read(self, f):
+            data = f.read(bytes)
+            return struct.unpack(sformat, data)[0]
+
+    return StructSerializer()
+
+
+uint64_BE: Serializer[int] = struct_serializer(">Q", bytes=8)
+"**unsigned 64bit integer - big endian**"
+
+uint64_LE: Serializer[int] = struct_serializer("<Q", bytes=8)
+"**unsigned 64bit integer - little endian**"
+
+uint64 = uint64_BE
+"**unsigned 64bit integer - big endian**"
+
+uint32_BE: Serializer[int] = struct_serializer(">I", bytes=4)
+"**unsigned 32bit integer - big endian**"
+
+uint32_LE: Serializer[int] = struct_serializer("<I", bytes=4)
+"**unsigned 32bit integer - little endian**"
+
+uint32 = uint32_BE
+"**unsigned 32bit integer - big endian**"
+
+uint16_BE: Serializer[int] = struct_serializer(">H", bytes=2)
+"**unsigned 16bit integer - big endian**"
+
+uint16_LE: Serializer[int] = struct_serializer("<H", bytes=2)
+"**unsigned 16bit integer - little endian**"
+
+uint16 = uint16_BE
+"**unsigned 16bit integer - big endian**"
+
+uint8: Serializer[int] = struct_serializer("B", bytes=1)
+"**unsigned 8bit integer**"
+
+int64_BE: Serializer[int] = struct_serializer(">q", bytes=8)
+"**signed 64bit integer - big endian**"
+
+int64_LE: Serializer[int] = struct_serializer("<q", bytes=8)
+"**signed 64bit integer - little endian**"
+
+int64 = int64_BE
+"**signed 64bit integer - big endian**"
+
+int32_BE: Serializer[int] = struct_serializer(">i", bytes=4)
+"**signed 32bit integer - big endian**"
+
+int32_LE: Serializer[int] = struct_serializer("<i", bytes=4)
+"**signed 32bit integer - little endian**"
+
+int32 = int32_BE
+"**signed 32bit integer - big endian**"
+
+int16_BE: Serializer[int] = struct_serializer(">h", bytes=2)
+"**signed 16bit integer - big endian**"
+
+int16_LE: Serializer[int] = struct_serializer("<h", bytes=2)
+"**signed 16bit integer - little endian**"
+
+int16 = int16_BE
+"**signed 16bit integer - big endian**"
+
+int8: Serializer[int] = struct_serializer("b", bytes=1)
+"**signed 8bit integer**"
+
+
+float64_BE: Serializer[float] = struct_serializer(">d", bytes=8)
+"**64bit float - big endian**"
+
+float64_LE: Serializer[float] = struct_serializer("<d", bytes=8)
+"**64bit float - little endian**"
+
+float64 = float64_BE
+"**64bit float - big endian**"
+
+float32_BE: Serializer[float] = struct_serializer(">f", bytes=4)
+"**32bit float - big endian**"
+
+float32_LE: Serializer[float] = struct_serializer("<f", bytes=4)
+"**32bit float - little endian**"
+
+float32 = float32_BE
+"**32bit float - big endian**"
+

structo/serializers/object.py

@@ -0,0 +1,52 @@
+import typing as t
+import io
+import annotationlib
+
+from ..interfaces import Serializer
+from ..objects import SerializableObject
+from ..serialise import get_serializer
+
+
+class ObjectSerializer[T: SerializableObject](Serializer[T]):
+    _annotations: dict[str, Serializer] = {}
+    _type: type
+
+    def __init__(self, type: type[T]) -> None:
+        annotations: dict[str, Serializer] = {}
+        self._type = type
+
+        attrs = annotationlib.get_annotations(type)
+        for key, value in attrs.items():
+            try:
+                annotations[key] = get_serializer(value)
+            except Exception as e:
+                raise ValueError(
+                    f"Invalid attribute defintion for {type.__name__}.{key}"
+                ) from e
+
+        self._annotations = annotations
+
+    def sizeof(self) -> int | None:
+        total_size = 0
+        for serializer in self._annotations.values():
+            field_size = serializer.sizeof()
+            if field_size is None:
+                return None
+            else:
+                total_size += field_size
+
+        return total_size
+
+    def write(self, f, value):
+        for field_key, field_format in self._annotations.items():
+            field_value = getattr(value, field_key)
+            field_format.write(f, field_value)
+
+    def read(self, f):
+        attrs = {}
+
+        for field_key, field_format in self._annotations.items():
+            field_value = field_format.read(f)
+            attrs[field_key] = field_value
+
+        return self._type(**attrs)

structo/serializers/optional.py

@@ -0,0 +1,39 @@
+from ..interfaces import Serializer
+
+
+NONE_TYPE_BYTE = b""
+VALUE_TYPE_BYTE = b""
+
+
+class Optional[T](Serializer[T | None]):
+    _value_type: Serializer[T]
+
+    def __init__(self, value: Serializer[T]) -> None:
+        self._value_type = value
+
+    def write(self, f, value):
+        if value is None:
+            f.write(NONE_TYPE_BYTE)
+        else:
+            f.write(VALUE_TYPE_BYTE)
+            self._value_type.write(f, value)
+
+    def read(self, f):
+        type_byte = f.read(1)
+
+        assert type_byte in (
+            NONE_TYPE_BYTE,
+            VALUE_TYPE_BYTE,
+        ), f"Unexpected type byte {type_byte}"
+
+        if type_byte == NONE_TYPE_BYTE:
+            return None
+        else:
+            return self._value_type.read(f)
+
+    def sizeof(self):
+        value_length = self._value_type.sizeof()
+        if value_length is None:
+            return None
+        else:
+            return value_length + 1

structo/serializers/packed.py

@@ -0,0 +1,57 @@
+from math import ceil
+
+from ..objects import PackedInts
+from ..interfaces import Serializer
+
+import typing as t
+
+
+class PackedIntSerializer[T: PackedInts](Serializer[T]):
+    _size: int
+    _bits: dict[str, int]
+    _cls: type[type[T]]
+
+    def __init__(self, cls: type[T]) -> None:
+        self._cls = cls
+        self._bits = cls._bits
+        self._size = self.sizeof()
+
+    def write(self, f, value):
+        output = 0
+        offset = 0
+        for field_key, bits in self._bits.items():
+            field_value = getattr(value, field_key)
+
+            max_value = (2**bits) - 1
+            assert (
+                field_value <= max_value
+            ), f"{self._cls.__name__}{field_key} exceed max value, {field_value} > {max_value}"
+            output += field_value << offset
+            offset += bits
+
+        data = bytearray(self._size)
+        for x in range(self._size):
+            byte = output & 255
+            output >>= 8
+            data[x] = byte
+
+        f.write(data)
+
+    def read(self, f):
+        data = f.read(self._size)
+        integer = int.from_bytes(data, "little")
+        attrs: dict[str, t.Any] = {}
+
+        offset = 0
+        for field_key, bits in self._bits.items():
+
+            mask = (2**bits) - 1
+            value = (integer >> offset) & mask
+
+            offset += bits
+            attrs[field_key] = value
+
+        return self._cls(**attrs)
+
+    def sizeof(self) -> int:
+        return ceil(sum(self._bits.values()) / 8)

structo/serializers/string.py

@@ -0,0 +1,27 @@
+import typing as t
+from .numbers import uint32_LE
+from ..interfaces import Serializer
+
+
+class String(Serializer[str]):
+    "A unicode string, prefixed with it's byte length"
+
+    _length_type: Serializer[int]
+
+    def __init__(self, length_type: Serializer[int] | None = None) -> None:
+        """_summary_
+
+        Args:
+            length_type (Serializer[int], optional): Defaults to uint32_LE
+        """
+        self._length_type = length_type or uint32_LE
+
+    def write(self, f, value):
+        data = value.encode("utf-8")
+        self._length_type.write(f, len(data))
+        f.write(data)
+
+    def read(self, f):
+        length = self._length_type.read(f)
+        data = f.read(length)
+        return data.decode("utf-8")

structo-0.0.10.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: structo
+Version: 0.0.10
+Summary: Structify
+Author-email: Ben Brady <benbradybusiness@gmail.com>
+Requires-Python: >=3.14
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: black>=26.1.0 ; extra == "dev"
+Requires-Dist: pytest>=9.0.2 ; extra == "dev"
+Requires-Dist: black ; extra == "docs"
+Requires-Dist: mkdocs ; extra == "docs"
+Requires-Dist: mkdocs-material ; extra == "docs"
+Requires-Dist: mkdocstrings[crystal, python] ; extra == "docs"
+Project-URL: Home, https://nnilky.site
+Provides-Extra: dev
+Provides-Extra: docs

structo-0.0.10.dist-info/RECORD

@@ -0,0 +1,21 @@
+structo/__init__.py,sha256=-QD1o5pnWc1lpWW6mvdUXVtoswjhJzJ97grj1uFr-ds,658
+structo/interfaces.py,sha256=ecmIOKz4Z06UNlUdspXzIjjCLiPJfZrahsFhEXSFjt8,1188
+structo/serialise.py,sha256=GsrxqQGanqVmaM6s1J3T8PSdit-AmrGhdmyGfEi-uwI,1640
+structo/objects/__init__.py,sha256=0FMm6WXU3PERdq_kU30u6ofTYAfQGmw_JQ6z4mC5Ru4,94
+structo/objects/packed.py,sha256=9Fr3xjme9wvuh51jsGlM9pPb58zVO3-o_PqdVKXU9VI,1486
+structo/objects/serializable_object.py,sha256=MsuJU1nrWULG7vXenUgkxB71xu9XKU4KaEEk0waOU_U,1250
+structo/serializers/__init__.py,sha256=wd5FxsqqqT8vOAKhvqLp3qL0PoOXhJhkrzc7f-8edrM,641
+structo/serializers/array.py,sha256=uYSEqTa2LYTINxgT2VWhi8dK5KgJyg-5_8kZx9sZZeA,964
+structo/serializers/blob.py,sha256=63wABDOVnbeUD2Tga2hO35eSu8quLEJZfFGvxhAciqY,542
+structo/serializers/buffer.py,sha256=7mIvqWVB679Sf9DpngnvVD1xMq-XnuWkq57W3QI8ccM,484
+structo/serializers/list.py,sha256=-1mUYWpN22uVcvOf2Igdt4cw9RNNbjz7xD2ZnmCz1S8,849
+structo/serializers/literal.py,sha256=ZQQ_SVFTwSe8cfOE9eeaw9j12ytYgvav0PPrve12JWY,857
+structo/serializers/numbers.py,sha256=bNyzRtpXRmHIPx93JOG_B2CqrfkOk09Dfb01LYBpEaY,2767
+structo/serializers/object.py,sha256=FH5w5GDwvo2P3HjWgmNDql_y0OlvpOVhGEjV0OqRxgs,1535
+structo/serializers/optional.py,sha256=nUyZDaB_UIDb4dPxDQSkSEzi387AOERwskR2zwoZGDQ,924
+structo/serializers/packed.py,sha256=RkhgXXfpOMYysolnL0mvezkyPje86ukOIYzUraAZ7k8,1471
+structo/serializers/string.py,sha256=A-wFOGgNbnHZHDkOfwetb-O1m59hvOIehTzfq66n2bU,732
+structo-0.0.10.dist-info/licenses/LICENSE,sha256=lOeFTSB86KGSl3-qqiI0zhIy0Nv-2USUp_93ANudE14,1076
+structo-0.0.10.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+structo-0.0.10.dist-info/METADATA,sha256=DNRhNUEVH2KDrTjD4-uHL--VTElJFNdWH_Bmr1m7C6Y,557
+structo-0.0.10.dist-info/RECORD,,

structo-0.0.10.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any

structo-0.0.10.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Ben Brady
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.