pybare 1.2.4__tar.gz → 1.3.0__tar.gz

{pybare-1.2.4 → pybare-1.3.0}/PKG-INFO

@@ -1,27 +1,28 @@
 Metadata-Version: 2.1
 Name: pybare
-Version: 1.2.4
+Version: 1.3.0
 Summary: A BARE Encoding Library and Data Validation Library for Python.
 Author-Email: Noah Pederson <noah@packetlost.dev>
 License: Copyright 2020 Noah Pederson
-        
-        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.
+         
+         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.
+         
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3.10
@@ -38,6 +39,8 @@ Description-Content-Type: text/markdown
 
 # PyBARE
 [![builds.sr.ht status](https://builds.sr.ht/~chiefnoah/pybare.svg)](https://builds.sr.ht/~chiefnoah/pybare?)
+[![Static
+Badge](https://img.shields.io/badge/Docs-green?style=flat&logo=python)](https://pybare.ngp.computer)
 
 A declarative implementation of the [BARE](https://baremessages.org/) message
 format for Python 3.10+

{pybare-1.2.4 → pybare-1.3.0}/README.md

@@ -1,5 +1,7 @@
 # PyBARE
 [![builds.sr.ht status](https://builds.sr.ht/~chiefnoah/pybare.svg)](https://builds.sr.ht/~chiefnoah/pybare?)
+[![Static
+Badge](https://img.shields.io/badge/Docs-green?style=flat&logo=python)](https://pybare.ngp.computer)
 
 A declarative implementation of the [BARE](https://baremessages.org/) message
 format for Python 3.10+

{pybare-1.2.4 → pybare-1.3.0}/bare/barestruct.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import io
-from typing import Any, BinaryIO, Dict, Type, TypeVar, _ProtocolMeta
+from typing import Any, BinaryIO, Type, TypeVar, _ProtocolMeta
 
 from .baretype import BAREType
 from .util import Field
@@ -67,14 +67,26 @@ class Struct(BAREType, metaclass=StructMeta):
 
     def __init__(self, **kwargs):
         name = self.__class__.__name__
-        for key, value in kwargs.items():
+        for key in kwargs:
             if key not in self._fields:
                 raise ValueError(f"Got unexpected field for Struct {name}: {key}")
-            if not isinstance(value, self._fields[key]):
-                value = self._fields[key](value)
+
+        missing_fields = []
+        for key, ty in self._fields.items():
+            field = self.__class__.__dict__[key]
+            if key in kwargs:
+                value = kwargs[key]
+            elif field.has_default():
+                value = field.get_default()
+            elif getattr(ty, "_optional", False):
+                value = None
+            else:
+                missing_fields.append(key)
+                continue
+            if not isinstance(value, ty):
+                value = ty(value)
             setattr(self, key, value)
-        missing_fields = set(kwargs.keys()) - set(self._fields.keys())
-        if len(missing_fields) > 0:
+        if missing_fields:
             raise ValueError(
                 f"Missing fields for {name}.__init__. "
                 f"Expected: {', '.join(missing_fields)}"
@@ -122,7 +134,7 @@ class Struct(BAREType, metaclass=StructMeta):
         return NotImplemented
 
 
-def struct(**kwargs: Dict[str, Type[BAREType]]) -> Type[Struct]:
+def struct(**kwargs: Type[BAREType]) -> Type[Struct]:
     """
     A function that defines and returnes an anonymous BARE `Struct` subclass with the
     provided `kwargs` as fields. The name of each kwarg becomes the field name, with the

{pybare-1.2.4 → pybare-1.3.0}/bare/baretype.py

@@ -7,14 +7,17 @@ T = TypeVar("T", covariant=True)
 
 class BAREType(Protocol, Generic[T]):
     @abstractmethod
-    def __init__(self, *arg, **kwargs): ...
+    def __init__(self, *arg, **kwargs):
+        ...
 
     @abstractmethod
-    def pack(self) -> bytes: ...
+    def pack(self) -> bytes:
+        ...
 
     @classmethod
     @abstractmethod
-    def unpack(cls, fp: BinaryIO) -> BAREType: ...
+    def unpack(cls, fp: BinaryIO) -> BAREType:
+        ...
 
     @classmethod
     @abstractmethod

{pybare-1.2.4 → pybare-1.3.0}/bare/data.py

@@ -68,6 +68,8 @@ class Data(BAREType[bytes], metaclass=DataMeta):
     def unpack(cls, fp: BinaryIO) -> Data:
         size = cls._size or UInt.unpack(fp).value
         buf = fp.read(size)
+        if len(buf) != size:
+            raise EOFError(f"Expected {size} data bytes, got {len(buf)}")
         return cls(buf)
 
 

{pybare-1.2.4 → pybare-1.3.0}/bare/number.py

@@ -113,7 +113,7 @@ class Int(NumberMixin[int]):
             return True
         try:
             value = int(value)
-            return -(1 << 63) <= value and value <= (1 << 63)
+            return -(1 << 63) <= value and value < (1 << 63)
         except (ValueError, TypeError):
             return False
 
@@ -139,7 +139,7 @@ class F64(NumberMixin[float]):
 
     @classmethod
     def unpack(cls, fp: BinaryIO) -> F64:
-        buf = fp.read(struct.calcsize("<d"))
+        buf = _read_exact(fp, struct.calcsize("<d"))
         return cls(struct.unpack("<d", buf)[0])
 
     @classmethod
@@ -172,7 +172,7 @@ class F32(NumberMixin[float]):
 
     @classmethod
     def unpack(cls, fp: BinaryIO) -> F32:
-        buf = fp.read(struct.calcsize("<f"))
+        buf = _read_exact(fp, struct.calcsize("<f"))
         return cls(struct.unpack("<f", buf)[0])  # type: ignore
 
     @classmethod
@@ -196,7 +196,7 @@ class U8(NumberMixin[int]):
 
     @classmethod
     def unpack(cls, fp: BinaryIO) -> U8:
-        buf = fp.read(struct.calcsize("<B"))
+        buf = _read_exact(fp, struct.calcsize("<B"))
         return cls(struct.unpack("<B", buf)[0])  # type: ignore
 
     @classmethod
@@ -220,7 +220,7 @@ class Bool(NumberMixin[bool]):
 
     @classmethod
     def unpack(cls, fp: BinaryIO) -> Bool:
-        buf = fp.read(struct.calcsize("<?"))
+        buf = _read_exact(fp, struct.calcsize("<?"))
         return cls(struct.unpack("<?", buf)[0])  # type: ignore
 
     @classmethod
@@ -238,7 +238,7 @@ class I8(NumberMixin[int]):
 
     @classmethod
     def unpack(cls, fp: BinaryIO) -> I8:
-        buf = fp.read(struct.calcsize("<b"))
+        buf = _read_exact(fp, struct.calcsize("<b"))
         return cls(struct.unpack("<b", buf)[0])  # type: ignore
 
     @classmethod
@@ -262,7 +262,7 @@ class U16(NumberMixin[int]):
 
     @classmethod
     def unpack(cls, fp: BinaryIO) -> U16:
-        buf = fp.read(struct.calcsize("<H"))
+        buf = _read_exact(fp, struct.calcsize("<H"))
         return cls(struct.unpack("<H", buf)[0])  # type: ignore
 
     @classmethod
@@ -286,7 +286,7 @@ class I16(NumberMixin[int]):
 
     @classmethod
     def unpack(cls, fp: BinaryIO) -> I16:
-        buf = fp.read(struct.calcsize("<h"))
+        buf = _read_exact(fp, struct.calcsize("<h"))
         return cls(struct.unpack("<h", buf)[0])  # type: ignore
 
     @classmethod
@@ -310,7 +310,7 @@ class U32(NumberMixin[int]):
 
     @classmethod
     def unpack(cls, fp: BinaryIO) -> U32:
-        buf = fp.read(struct.calcsize("<L"))
+        buf = _read_exact(fp, struct.calcsize("<L"))
         return cls(struct.unpack("<L", buf)[0])  # type: ignore
 
     @classmethod
@@ -334,7 +334,7 @@ class I32(NumberMixin[int]):
 
     @classmethod
     def unpack(cls, fp: BinaryIO) -> I32:
-        buf = fp.read(struct.calcsize("<l"))
+        buf = _read_exact(fp, struct.calcsize("<l"))
         return cls(struct.unpack("<l", buf)[0])  # type: ignore
 
     @classmethod
@@ -358,7 +358,7 @@ class U64(NumberMixin[int]):
 
     @classmethod
     def unpack(cls, fp: BinaryIO) -> U64:
-        buf = fp.read(struct.calcsize("<Q"))
+        buf = _read_exact(fp, struct.calcsize("<Q"))
         return cls(struct.unpack("<Q", buf)[0])  # type: ignore
 
     @classmethod
@@ -385,7 +385,7 @@ class I64(NumberMixin[int]):
 
     @classmethod
     def unpack(cls, fp: BinaryIO) -> I64:
-        buf = fp.read(struct.calcsize("<q"))
+        buf = _read_exact(fp, struct.calcsize("<q"))
         return cls(struct.unpack("<q", buf)[0])  # type: ignore
 
     @classmethod
@@ -399,6 +399,13 @@ class I64(NumberMixin[int]):
             return False
 
 
+def _read_exact(fp: BinaryIO, size: int) -> bytes:
+    buf = fp.read(size)
+    if len(buf) != size:
+        raise EOFError(f"Expected {size} bytes, got {len(buf)}")
+    return buf
+
+
 # This is adapted from https://git.sr.ht/~martijnbraam/bare-py/tree/master/bare/__init__.py#L29
 def _write_varint(fp: BinaryIO, val: int, signed=True) -> int:
     written = 0
@@ -416,19 +423,22 @@ def _write_varint(fp: BinaryIO, val: int, signed=True) -> int:
 
 def _read_varint(fp: BinaryIO, signed=True) -> int:
     output = 0
-    offset = 0
-    while True:
-        try:
-            b = fp.read(1)[0]
-        except IndexError:
-            raise RuntimeError("Not enough bytes in buffer to decode")
+    for index in range(10):
+        buf = fp.read(1)
+        if not buf:
+            raise EOFError("Not enough bytes in buffer to decode varint")
+        b = buf[0]
+        if index == 9 and b > 1:
+            raise ValueError("Varint exceeds 64 bits")
         if b < 0x80:
-            value = output | b << offset
+            if index > 0 and b == 0:
+                raise ValueError("Varint is not canonically encoded")
+            value = output | b << (index * 7)
             if signed:
                 sign = value % 2
                 value = value // 2
                 if sign:
                     value = -(value + 1)
             return value
-        output |= (b & 0x7F) << offset
-        offset += 7
+        output |= (b & 0x7F) << (index * 7)
+    raise ValueError("Varint exceeds 64 bits")

{pybare-1.2.4 → pybare-1.3.0}/bare/test_barearray.py

@@ -5,11 +5,15 @@ import bare
 import pytest
 import io
 
+__all__ = []
+
 
 def test_2d_array_unsized():
-    class InnerArray(Array, inner=UInt): ...
+    class InnerArray(Array, inner=UInt):
+        ...
 
-    class My2DArray(Array, inner=InnerArray): ...
+    class My2DArray(Array, inner=InnerArray):
+        ...
 
     input = [[1, 2], [3, 4]]
     x = My2DArray(input)
@@ -45,7 +49,8 @@ def test_anonymous_array_sized():
 
 
 def test_array_sized():
-    class MyArry(Array, inner=UInt, size=3): ...
+    class MyArry(Array, inner=UInt, size=3):
+        ...
 
     input = [1, 2, 3]
     x = MyArry(input)

pybare-1.3.0/bare/test_barestruct.py

@@ -0,0 +1,108 @@
+import io
+from bare import Struct, UInt, Str, Void, Field, array, optional, struct
+import pytest
+
+__all__ = []
+
+
+def test_struct_basic():
+    class MyStruct(Struct):
+        a = Field(UInt)
+        b = Field(Str)
+        c: int
+
+    x = MyStruct(a=123, b="Hello")
+    b = x.pack()
+    x2 = MyStruct.unpack(io.BytesIO(b))
+    assert x == x2
+
+
+def test_struct_requires_all_fields():
+    class MyStruct(Struct):
+        a = Field(UInt)
+        b = Field(Str)
+
+    with pytest.raises(ValueError, match="Missing fields"):
+        MyStruct(a=1)
+
+    with pytest.raises(ValueError, match="Missing fields"):
+        MyStruct()
+
+
+def test_struct_field_default():
+    class MyStruct(Struct):
+        name = Field(Str)
+        count = Field(UInt, default=0)
+
+    value = MyStruct(name="example")
+
+    assert value.count == 0
+    assert MyStruct.unpack(io.BytesIO(value.pack())) == value
+
+
+def test_struct_field_default_factory_is_fresh_per_instance():
+    Values = array(UInt)
+
+    class MyStruct(Struct):
+        values = Field(Values, default_factory=list)
+
+    first = MyStruct()
+    second = MyStruct()
+    first.values.append(1)
+
+    assert first.values == [1]
+    assert second.values == []
+
+
+def test_struct_field_default_is_validated():
+    class MyStruct(Struct):
+        count = Field(UInt, default=-1)
+
+    with pytest.raises(TypeError):
+        MyStruct()
+
+
+def test_field_rejects_default_and_default_factory():
+    with pytest.raises(TypeError, match="both default and default_factory"):
+        Field(UInt, default=0, default_factory=lambda: 0)
+
+
+def test_optional_struct_field_defaults_to_void():
+    class MyStruct(Struct):
+        name = Field(Str)
+        description = Field(optional(Str))
+
+    value = MyStruct(name="example")
+
+    assert value.description == Void()
+    assert MyStruct.unpack(io.BytesIO(value.pack())) == value
+
+
+def test_explicit_optional_struct_field_overrides_implicit_default():
+    class MyStruct(Struct):
+        description = Field(optional(Str))
+
+    value = MyStruct(description=Str("provided"))
+
+    assert value.description == "provided"
+
+
+def test_nested_struct():
+    class InnerStruct(Struct):
+        i = Field(UInt)
+
+    class MyStruct(Struct):
+        inner = Field(InnerStruct)
+
+    x = MyStruct(inner=InnerStruct(i=123))
+    b = x.pack()
+    x2 = MyStruct.unpack(io.BytesIO(b))
+    assert x == x2
+
+
+def test_anonymous_struct():
+    MyStruct = struct(name=Str, age=UInt)
+    x = MyStruct(name="Noah", age=27)
+    b = x.pack()
+    x2 = MyStruct.unpack(io.BytesIO(b))
+    assert x == x2

{pybare-1.2.4 → pybare-1.3.0}/bare/test_data.py

@@ -1,9 +1,13 @@
-from bare import Data, data
+from bare import Data
 import io
+import pytest
+
+__all__ = []
 
 
 def test_data_sized():
-    class SizedData(Data, size=5): ...
+    class SizedData(Data, size=5):
+        ...
 
     x = SizedData(b"12345")
     b = x.pack()
@@ -13,7 +17,8 @@ def test_data_sized():
 
 
 def test_data_unsized():
-    class SizedData(Data): ...
+    class SizedData(Data):
+        ...
 
     x = SizedData(b"12345")
     b = x.pack()
@@ -28,3 +33,16 @@ def test_data_raw():
     assert len(b) == 6
     x2 = Data.unpack(io.BytesIO(b))
     assert x == x2
+
+
+def test_data_rejects_truncated_input():
+    with pytest.raises(EOFError):
+        Data.unpack(io.BytesIO(b"\x05abc"))
+
+
+def test_sized_data_rejects_truncated_input():
+    class SizedData(Data, size=5):
+        ...
+
+    with pytest.raises(EOFError):
+        SizedData.unpack(io.BytesIO(b"abc"))

{pybare-1.2.4 → pybare-1.3.0}/bare/test_encoder.py

@@ -27,6 +27,8 @@ from bare import (
     UnionVariant,
 )
 
+__all__ = []
+
 
 class Nested(Struct):
     s = Field(Str)
@@ -42,7 +44,7 @@ class Example(Struct):
 
 def test_example_struct():
     n = Nested(s="nested")
-    ex = Example(testint=11, teststr="a test", n=n)
+    ex = Example(testint=11, teststr="a test", testuint=0, n=n)
     assert hasattr(ex, "testint")
     assert hasattr(ex, "teststr")
     assert hasattr(ex, "n")
@@ -50,7 +52,7 @@ def test_example_struct():
     assert ex.testint == 11
     assert ex.teststr == "a test"
     assert ex.n.s == "nested"
-    ex2 = Example(testint=12, teststr="another test")
+    ex2 = Example(testint=12, teststr="another test", testuint=0, n=n)
     assert ex2.testint == 12
     assert ex2.teststr == "another test"
     # Check that the values in the original instance haven't been modified
@@ -100,7 +102,8 @@ def test_map():
     assert map2.value["another"] == "test"
 
 
-class MyArray(Array, inner=Int): ...
+class MyArray(Array, inner=Int):
+    ...
 
 
 class ArrayTest(Struct):
@@ -109,9 +112,7 @@ class ArrayTest(Struct):
 
 
 def test_array_struct():
-    ex = ArrayTest()
-    ex.a = [1, 2, 3]
-    ex.n = [Nested(s="test")]
+    ex = ArrayTest(a=[1, 2, 3], n=[Nested(s="test")])
     assert ex.a == [1, 2, 3]
     with pytest.raises(TypeError):
         ex.a = ["a", "b", "c"]
@@ -141,7 +142,8 @@ def test_optional():
         ex.nested = "test"
 
 
-class ExampleUnion(Union, variants=(Str, Int)): ...
+class ExampleUnion(Union, variants=(Str, Int)):
+    ...
 
 
 class UnionTest(Struct):
@@ -234,7 +236,8 @@ class TerminatedEmployee(Void):
     pass
 
 
-class Person(Union, variants=(Customer, Employee, TerminatedEmployee)): ...
+class Person(Union, variants=(Customer, Employee, TerminatedEmployee)):
+    ...
 
 
 @pytest.mark.parametrize(
@@ -247,7 +250,7 @@ def test_people(file):
             try:
                 p = Person.unpack(f)
                 people.append(p)
-            except RuntimeError:
+            except EOFError:
                 break
         f.seek(0)
         f = f.read()

{pybare-1.2.4 → pybare-1.3.0}/bare/test_map.py

@@ -4,8 +4,11 @@ import io
 
 import pytest
 
+__all__ = []
 
-class MyMap(Map, key_type=Str, value_type=Int): ...
+
+class MyMap(Map, key_type=Str, value_type=Int):
+    ...
 
 
 def test_basic_map():
@@ -30,7 +33,8 @@ def test_anonymous_map():
 def test_nested_map():
     InnerMap = map(Str, Str)
 
-    class NestedMap(Map, key_type=Str, value_type=InnerMap): ...
+    class NestedMap(Map, key_type=Str, value_type=InnerMap):
+        ...
 
     x = NestedMap({"outer": {"hello": "world"}})
     b = x.pack()

{pybare-1.2.4 → pybare-1.3.0}/bare/test_misc.py

@@ -3,6 +3,8 @@ from bare import Enum, UInt, Void, Str
 import io
 import pytest
 
+__all__ = []
+
 
 class MyEnum(Enum):
     A = 1
@@ -19,7 +21,8 @@ def test_enum_basic():
         MyEnum.unpack(io.BytesIO(b))
 
 
-class MyVoid(Void): ...
+class MyVoid(Void):
+    ...
 
 
 def test_custom_void():

pybare-1.3.0/bare/test_number.py

@@ -0,0 +1,93 @@
+import io
+import bare
+import pytest
+
+__all__ = []
+
+
+@pytest.mark.parametrize(
+    "type_, good_values, bad_values",
+    [
+        (bare.UInt, [0, 1, 2**64 - 1], [-1, 2**64, 2**64 + 1]),
+        (
+            bare.Int,
+            [-(2**63), -(2**63) + 1, 0, 2**63 - 1],
+            [-(2**63) - 1, 2**63, 2**63 + 1],
+        ),
+        (bare.U8, [0, 1, 2**8 - 1], [-1, 2**8]),
+        (bare.I8, [-(2**7), 0, 2**7 - 1], [-(2**7) - 1, 2**7]),
+        (bare.U16, [0, 1, 2**16 - 1], [-1, 2**16]),
+        (bare.I16, [-(2**15), 0, 2**15 - 1], [-(2**15) - 1, 2**15]),
+        (bare.U32, [0, 1, 2**32 - 1], [-1, 2**32]),
+        (bare.I32, [-(2**31), 0, 2**31 - 1], [-(2**31) - 1, 2**31]),
+        (bare.U64, [0, 1, 2**64 - 1], [-1, 2**64]),
+        (bare.I64, [-(2**63), 0, 2**63 - 1], [-(2**63) - 1, 2**63]),
+    ],
+)
+def test_bounds(type_, good_values, bad_values):
+    for value in good_values:
+        x = type_(value)
+        encoded = x.pack()
+        decoded = type_.unpack(io.BytesIO(encoded))
+        assert decoded == x
+        assert decoded.value == value
+    for value in bad_values:
+        with pytest.raises(TypeError):
+            type_(value)
+
+
+@pytest.mark.parametrize("value", [-(2**63), -(2**63) + 1, 0, 2**63 - 1])
+def test_int_boundary_values_roundtrip(value):
+    encoded = bare.Int(value).pack()
+    decoded = bare.Int.unpack(io.BytesIO(encoded))
+
+    assert decoded.value == value
+    assert decoded.pack() == encoded
+
+
+@pytest.mark.parametrize("value", [-(2**63) - 1, 2**63])
+def test_int_rejects_values_that_cannot_roundtrip(value):
+    with pytest.raises(TypeError):
+        bare.Int(value).pack()
+
+
+def test_f32():
+    x = bare.F32(123.5)
+    b = x.pack()
+    assert len(b) == 4
+    x2 = bare.F32.unpack(io.BytesIO(b))
+    assert x == x2
+
+
+def test_f64():
+    x = bare.F64(123.5)
+    b = x.pack()
+    assert len(b) == 8
+    x2 = bare.F64.unpack(io.BytesIO(b))
+    assert x == x2
+
+
+@pytest.mark.parametrize("encoded", [b"\x80\x00", b"\x80" * 10 + b"\x00"])
+def test_uint_rejects_noncanonical_or_oversized_varints(encoded):
+    with pytest.raises(ValueError):
+        bare.UInt.unpack(io.BytesIO(encoded))
+
+
+@pytest.mark.parametrize(
+    "type_,size",
+    [
+        (bare.F32, 4),
+        (bare.F64, 8),
+        (bare.U8, 1),
+        (bare.I8, 1),
+        (bare.U16, 2),
+        (bare.I16, 2),
+        (bare.U32, 4),
+        (bare.I32, 4),
+        (bare.U64, 8),
+        (bare.I64, 8),
+    ],
+)
+def test_fixed_width_number_rejects_truncated_input(type_, size):
+    with pytest.raises(EOFError):
+        type_.unpack(io.BytesIO(b"\x00" * (size - 1)))

{pybare-1.2.4 → pybare-1.3.0}/bare/test_union.py

@@ -3,8 +3,11 @@ import bare
 import io
 import pytest
 
+__all__ = []
 
-class MyUnion(Union, variants=(Str, Int)): ...
+
+class MyUnion(Union, variants=(Str, Int)):
+    ...
 
 
 def test_union_basic():
@@ -37,7 +40,8 @@ def test_anonymous_union():
 
 
 def test_explicit_discriminant_implicit_following():
-    class MyUnion(Union, variants=(UnionVariant(Str, 4), Int)): ...
+    class MyUnion(Union, variants=(UnionVariant(Str, 4), Int)):
+        ...
 
     x = MyUnion(Str("Hello"))
     b = x.pack()
@@ -57,7 +61,8 @@ def test_explicit_discriminant_implicit_following():
 
 
 def test_explicit_discriminant_all_cases():
-    class MyUnion(Union, variants=(UnionVariant(Str, 4), UnionVariant(Int, 10))): ...
+    class MyUnion(Union, variants=(UnionVariant(Str, 4), UnionVariant(Int, 10))):
+        ...
 
     x = MyUnion(Str("Hello"))
     b = x.pack()
@@ -96,7 +101,8 @@ class AllPrimativeTypes(
         bare.Data,
         bare.Void,
     ),
-): ...
+):
+    ...
 
 
 @pytest.mark.parametrize(

{pybare-1.2.4 → pybare-1.3.0}/bare/union.py

@@ -210,6 +210,7 @@ def optional(maybe: Type[T]) -> Type[Union]:
         maybe,
     )
     namespace = UnionMeta.__prepare__(name, (), variants=variants)
+    namespace["_optional"] = True
     AnonymousUnion = UnionMeta.__new__(
         UnionMeta, name, (Union,), namespace, variants=variants
     )

pybare-1.3.0/bare/util.py

@@ -0,0 +1,65 @@
+from typing import Any, Callable, Type, TypeVar
+from .misc import Enum
+
+from .baretype import BAREType
+
+T = TypeVar("T", bound=BAREType)
+_MISSING = object()
+
+
+class Field:
+    """
+    A descriptor that assists with assigning/retrieving values from a BARE Struct.
+    It is reponsible for performing type validation on assignment of struct fields.
+
+    For example:
+
+    ```
+    class MyStruct(Struct):
+        a = Field(UInt)
+        b = Field(Str)
+    ```
+    """
+
+    attr: str
+    name: str
+    ty: Type[BAREType | Enum]
+
+    def __init__(
+        self,
+        ty: Type[BAREType | Enum],
+        attr: str | None = None,
+        *,
+        default: Any = _MISSING,
+        default_factory: Callable[[], Any] | None = None,
+    ):
+        if default is not _MISSING and default_factory is not None:
+            raise TypeError("Field cannot specify both default and default_factory")
+        if default_factory is not None and not callable(default_factory):
+            raise TypeError("Field default_factory must be callable")
+        # ignore the typing here because these will always be set when assigned to an
+        # object
+        self.attr = attr  # type: ignore
+        self.ty = ty
+        self.default = default
+        self.default_factory = default_factory
+
+    def has_default(self) -> bool:
+        return self.default is not _MISSING or self.default_factory is not None
+
+    def get_default(self) -> Any:
+        if self.default_factory is not None:
+            return self.default_factory()
+        return self.default
+
+    def __get__(self, inst, _) -> T | Type[BAREType[T] | Enum]:
+        if inst is None:
+            return self.ty
+        return inst.__dict__[self.attr]
+
+    def __set__(self, inst, value: T):
+        if not isinstance(value, self.ty) and not self.ty.validate(value):
+            raise TypeError(
+                f"type {type(value)} is invalid for field of BARE type {self.ty}"
+            )
+        inst.__dict__[self.attr] = value

{pybare-1.2.4 → pybare-1.3.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "pybare"
-version = "1.2.4"
+version = "1.3.0"
 description = "A BARE Encoding Library and Data Validation Library for Python."
 dependencies = []
 requires-python = ">= 3.10"

pybare-1.2.4/bare/test_barestruct.py

@@ -1,35 +0,0 @@
-import io
-from bare import Struct, UInt, Str, Field, struct
-
-
-def test_struct_basic():
-    class MyStruct(Struct):
-        a = Field(UInt)
-        b = Field(Str)
-        c: int
-
-    x = MyStruct(a=123, b="Hello")
-    b = x.pack()
-    x2 = MyStruct.unpack(io.BytesIO(b))
-    assert x == x2
-
-
-def test_nested_struct():
-    class InnerStruct(Struct):
-        i = Field(UInt)
-
-    class MyStruct(Struct):
-        inner = Field(InnerStruct)
-
-    x = MyStruct(inner=InnerStruct(i=123))
-    b = x.pack()
-    x2 = MyStruct.unpack(io.BytesIO(b))
-    assert x == x2
-
-
-def test_anonymous_struct():
-    MyStruct = struct(name=Str, age=UInt)
-    x = MyStruct(name="Noah", age=27)
-    b = x.pack()
-    x2 = MyStruct.unpack(io.BytesIO(b))
-    assert x == x2

pybare-1.2.4/bare/test_number.py

@@ -1,49 +0,0 @@
-import io
-import bare
-import pytest
-
-
-@pytest.mark.parametrize(
-    "type_, good_values, bad_values",
-    [
-        (bare.UInt, [0, 1, 2**64 - 1], [-1, 2**64, 2**64 + 1]),
-        (
-            bare.Int,
-            [-(2**63), -(2**63) + 1, 0, 2**63, 2**63 - 1],
-            [-(2**63) - 1, 2**63 + 1],
-        ),
-        (bare.U8, [0, 1, 2**8 - 1], [-1, 2**8]),
-        (bare.I8, [-(2**7), 0, 2**7 - 1], [-(2**7) - 1, 2**7]),
-        (bare.U16, [0, 1, 2**16 - 1], [-1, 2**16]),
-        (bare.I16, [-(2**15), 0, 2**15 - 1], [-(2**15) - 1, 2**15]),
-        (bare.U32, [0, 1, 2**32 - 1], [-1, 2**32]),
-        (bare.I32, [-(2**31), 0, 2**31 - 1], [-(2**31) - 1, 2**31]),
-        (bare.U64, [0, 1, 2**64 - 1], [-1, 2**64]),
-        (bare.I64, [-(2**63), 0, 2**63 - 1], [-(2**63) - 1, 2**63]),
-    ],
-)
-def test_bounds(type_, good_values, bad_values):
-    for value in good_values:
-        x = type_(value)
-        b = x.pack()
-        x2 = type_.unpack(io.BytesIO(b))
-        assert x == x2
-    for value in bad_values:
-        with pytest.raises(TypeError):
-            type_(value)
-
-
-def test_f32():
-    x = bare.F32(123.5)
-    b = x.pack()
-    assert len(b) == 4
-    x2 = bare.F32.unpack(io.BytesIO(b))
-    assert x == x2
-
-
-def test_f64():
-    x = bare.F64(123.5)
-    b = x.pack()
-    assert len(b) == 8
-    x2 = bare.F64.unpack(io.BytesIO(b))
-    assert x == x2

pybare-1.2.4/bare/util.py

@@ -1,42 +0,0 @@
-from typing import Generic, Type, TypeVar
-
-from .baretype import BAREType
-
-T = TypeVar("T", bound=BAREType)
-
-
-class Field:
-    """
-    A descriptor that assists with assigning/retrieving values from a BARE Struct.
-    It is reponsible for performing type validation on assignment of struct fields.
-
-    For example:
-
-    ```
-    class MyStruct(Struct):
-        a = Field(UInt)
-        b = Field(Str)
-    ```
-    """
-
-    attr: str
-    name: str
-    ty: Type[BAREType]
-
-    def __init__(self, ty: Type[BAREType], attr: str | None = None):
-        # ignore the typing here because these will always be set when assigned to an
-        # object
-        self.attr = attr  # type: ignore
-        self.ty = ty
-
-    def __get__(self, inst, _) -> T | Type[BAREType[T]]:
-        if inst is None:
-            return self.ty
-        return inst.__dict__[self.attr]
-
-    def __set__(self, inst, value: T):
-        if not isinstance(value, self.ty) and not self.ty.validate(value):
-            raise TypeError(
-                f"type {type(value)} is invalid for field of BARE type {self.ty}"
-            )
-        inst.__dict__[self.attr] = value