pybare 1.2.3__tar.gz → 1.2.5__tar.gz

{pybare-1.2.3/pybare.egg-info → pybare-1.2.5}/PKG-INFO

@@ -1,21 +1,46 @@
 Metadata-Version: 2.1
 Name: pybare
-Version: 1.2.3
-Summary: A declarative implementation of BARE for Python
-Home-page: https://sr.ht/~chiefnoah/pybare/
-Author: Noah Pederson
-Author-email: noah@packetlost.dev
+Version: 1.2.5
+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.
+         
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
+Project-URL: Homepage, https://sr.ht/~chiefnoah/pybare/
+Project-URL: Repository, https://git.sr.ht/~chiefnoah/pybare
+Project-URL: Issues, https://todo.sr.ht/~chiefnoah/pybare
+Project-URL: Changelog, https://git.sr.ht/~chiefnoah/pybare/tree/master/item/CHANGELOG.md
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-License-File: LICENSE
 
 # 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+
@@ -40,6 +65,8 @@ pip install pybare
 pybare fully implements all BARE types for both encoding and decoding. This
 includes reading multiple messages from the same `BinaryIO` stream.
 
+It is well tested and in use on production systems.
+
 ## Gotchas
 
 We use "Array" / "array" instead of "List" / "list" to avoid conflicts with Python's

{pybare-1.2.3 → pybare-1.2.5}/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+
@@ -24,6 +26,8 @@ pip install pybare
 pybare fully implements all BARE types for both encoding and decoding. This
 includes reading multiple messages from the same `BinaryIO` stream.
 
+It is well tested and in use on production systems.
+
 ## Gotchas
 
 We use "Array" / "array" instead of "List" / "list" to avoid conflicts with Python's

pybare-1.2.5/bare/_examples/terminated.bin

@@ -0,0 +1 @@
+

{pybare-1.2.3 → pybare-1.2.5}/bare/barearray.py

@@ -1,8 +1,17 @@
 from __future__ import annotations
 import io
 from collections import UserList
-from typing import (Any, BinaryIO, ClassVar, Generic, Iterable, Optional, Type,
-                    TypeVar, _ProtocolMeta)
+from typing import (
+    Any,
+    BinaryIO,
+    ClassVar,
+    Generic,
+    Iterable,
+    Optional,
+    Type,
+    TypeVar,
+    _ProtocolMeta,
+)
 
 from .baretype import BAREType
 from .number import UInt

{pybare-1.2.3 → pybare-1.2.5}/bare/barestruct.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
 
-from typing import Any, BinaryIO, _ProtocolMeta, Type, Dict, TypeVar
+import io
+from typing import Any, BinaryIO, Dict, Type, TypeVar, _ProtocolMeta
 
-from .util import Field
 from .baretype import BAREType
+from .util import Field
 
 __all__ = ["Struct", "struct"]
 
 
 T = TypeVar("T")
 
+
 class StructMeta(_ProtocolMeta, type):
     def __new__(cls, clsname, bases, clsdict):
         fields = {}
@@ -79,8 +81,6 @@ class Struct(BAREType, metaclass=StructMeta):
             )
 
     def pack(self: Struct) -> bytes:
-        import io
-
         buf = io.BytesIO()
         for name, ty in self._fields.items():
             val = getattr(self, name)
@@ -121,7 +121,8 @@ class Struct(BAREType, metaclass=StructMeta):
             return True
         return NotImplemented
 
-def struct(**kwargs: Dict[str, BAREType[T]]) -> 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.3 → pybare-1.2.5}/bare/map.py

@@ -115,7 +115,10 @@ class Map(BAREType[dict[K, V]], metaclass=MapMeta):
             return other._values == self._values
         try:
             for other_key, other_value in other.values():
-                if other_key not in self._values and self._key_type(other_key) not in self._values:
+                if (
+                    other_key not in self._values
+                    and self._key_type(other_key) not in self._values
+                ):
                     return False
                 if other_value != self._values[other_key]:
                     return False

{pybare-1.2.3 → pybare-1.2.5}/bare/misc.py

@@ -60,7 +60,7 @@ class Enum(IntEnum, metaclass=EnumMeta):
             return False
 
 
-class Void:
+class Void(BAREType[None]):
     """
     A Void type. It is similar to the `None` type, but is used to represent
     a BARE void type.
@@ -68,11 +68,14 @@ class Void:
     If should *generally* be used directly, but is also used implicitly in `option`.
     """
 
+    def __init__(self):
+        ...
+
     def pack(self) -> bytes:
         return bytes()
 
     @classmethod
-    def unpack(cls, _: BinaryIO) -> Void:
+    def unpack(cls, fp: BinaryIO) -> Void:
         return cls()
 
     def __eq__(self, other: Any) -> bool:

{pybare-1.2.3 → pybare-1.2.5}/bare/test_barearray.py

@@ -5,9 +5,13 @@ import bare
 import pytest
 import io
 
+__all__ = []
+
+
 def test_2d_array_unsized():
     class InnerArray(Array, inner=UInt):
         ...
+
     class My2DArray(Array, inner=InnerArray):
         ...
 
@@ -18,6 +22,7 @@ def test_2d_array_unsized():
     assert x2 == x
     assert x2 == input
 
+
 def test_anonymous_array_unsized():
     AnonymousArray = array(UInt)
     input = [1, 2, 3]
@@ -27,6 +32,7 @@ def test_anonymous_array_unsized():
     assert x2 == x
     assert x2 == input
 
+
 def test_anonymous_array_sized():
     AnonymousArray = array(UInt, 3)
     input = [1, 2, 3]
@@ -41,6 +47,7 @@ def test_anonymous_array_sized():
     with pytest.raises(ValueError):
         AnonymousArray([1, 2, 3, 4])
 
+
 def test_array_sized():
     class MyArry(Array, inner=UInt, size=3):
         ...
@@ -56,24 +63,28 @@ def test_array_sized():
     with pytest.raises(ValueError):
         MyArry([1, 2, 3, 4])
 
-@pytest.mark.parametrize('inner,data', [
-    (bare.I8, [1, -1]),
-    (bare.U8, [1, 5]),
-    (bare.I16, [-1, 10000]),
-    (bare.U16, [1, 100]),
-    (bare.I32, [1, 100]),
-    (bare.U32,[1, 100]),
-    (bare.I64,[1, 100]),
-    (bare.U64,[1, 100]),
-    (bare.F32, [1.0, 2.0]),
-    (bare.F64, [1.1, 2.2]),
-    (bare.UInt, [1, 2, 3]),
-    (bare.Int, [-1, 2, -3]),
-    (bare.Str, ["Hello", "world"]),
-    (bare.Bool, [False, True]),
-    (bare.map(bare.Str, bare.Str), [{"Hello": "world"}, {"abc": "123"}]),
-    (bare.union(bare.Str, bare.UInt), [bare.Str("hello"), bare.UInt(123)]),
-])
+
+@pytest.mark.parametrize(
+    "inner,data",
+    [
+        (bare.I8, [1, -1]),
+        (bare.U8, [1, 5]),
+        (bare.I16, [-1, 10000]),
+        (bare.U16, [1, 100]),
+        (bare.I32, [1, 100]),
+        (bare.U32, [1, 100]),
+        (bare.I64, [1, 100]),
+        (bare.U64, [1, 100]),
+        (bare.F32, [1.0, 2.0]),
+        (bare.F64, [1.1, 2.2]),
+        (bare.UInt, [1, 2, 3]),
+        (bare.Int, [-1, 2, -3]),
+        (bare.Str, ["Hello", "world"]),
+        (bare.Bool, [False, True]),
+        (bare.map(bare.Str, bare.Str), [{"Hello": "world"}, {"abc": "123"}]),
+        (bare.union(bare.Str, bare.UInt), [bare.Str("hello"), bare.UInt(123)]),
+    ],
+)
 def test_all_types(inner: Type[BAREType], data: list):
     anon_array = array(inner)
     x = anon_array(data)

{pybare-1.2.3 → pybare-1.2.5}/bare/test_barestruct.py

@@ -1,16 +1,21 @@
 import io
 from bare import Struct, UInt, Str, Field, struct
 
+__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_nested_struct():
     class InnerStruct(Struct):
         i = Field(UInt)
@@ -23,6 +28,7 @@ def test_nested_struct():
     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)

{pybare-1.2.3 → pybare-1.2.5}/bare/test_data.py

@@ -1,29 +1,33 @@
 from bare import Data, data
 import io
 
+__all__ = []
+
 
 def test_data_sized():
     class SizedData(Data, size=5):
         ...
 
-    x = SizedData(b'12345')
+    x = SizedData(b"12345")
     b = x.pack()
     assert len(b) == 5
     x2 = SizedData.unpack(io.BytesIO(b))
     assert x == x2
 
+
 def test_data_unsized():
     class SizedData(Data):
         ...
 
-    x = SizedData(b'12345')
+    x = SizedData(b"12345")
     b = x.pack()
     assert len(b) == 6
     x2 = SizedData.unpack(io.BytesIO(b))
     assert x == x2
 
+
 def test_data_raw():
-    x = Data(b'12345')
+    x = Data(b"12345")
     b = x.pack()
     assert len(b) == 6
     x2 = Data.unpack(io.BytesIO(b))

{pybare-1.2.3 → pybare-1.2.5}/bare/test_encoder.py

@@ -27,6 +27,8 @@ from bare import (
     UnionVariant,
 )
 
+__all__ = []
+
 
 class Nested(Struct):
     s = Field(Str)
@@ -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):
@@ -141,7 +144,8 @@ def test_optional():
         ex.nested = "test"
 
 
-class ExampleUnion(Union, variants=(Str, Int)): ...
+class ExampleUnion(Union, variants=(Str, Int)):
+    ...
 
 
 class UnionTest(Struct):
@@ -234,7 +238,8 @@ class TerminatedEmployee(Void):
     pass
 
 
-class Person(Union, variants=(Customer, Employee, TerminatedEmployee)): ...
+class Person(Union, variants=(Customer, Employee, TerminatedEmployee)):
+    ...
 
 
 @pytest.mark.parametrize(

{pybare-1.2.3 → pybare-1.2.5}/bare/test_map.py

@@ -4,10 +4,13 @@ import io
 
 import pytest
 
+__all__ = []
+
 
 class MyMap(Map, key_type=Str, value_type=Int):
     ...
 
+
 def test_basic_map():
     x = MyMap({"Hello": 123, "abc": 456})
     b = x.pack()
@@ -16,6 +19,7 @@ def test_basic_map():
     assert x["Hello"] == 123
     assert x["abc"] == 456
 
+
 def test_anonymous_map():
     MyMap = map(Str, Int)
     x = MyMap({"Hello": 123, "abc": 456})
@@ -25,37 +29,42 @@ def test_anonymous_map():
     assert x["Hello"] == 123
     assert x["abc"] == 456
 
+
 def test_nested_map():
     InnerMap = map(Str, Str)
+
     class NestedMap(Map, key_type=Str, value_type=InnerMap):
         ...
+
     x = NestedMap({"outer": {"hello": "world"}})
     b = x.pack()
     x2 = NestedMap.unpack(io.BytesIO(b))
     assert x == x2
 
+
 class MyEnum(bare.Enum):
     A = 1
     B = 2
 
+
 @pytest.mark.parametrize(
-    'key_type,value_type,data',
+    "key_type,value_type,data",
     [
         (Str, Str, {"hello": "world"}),
         (bare.UInt, bare.Int, {123: -123}),
-        (bare.U8, bare.U8, {1:2}),
-        (bare.I8, bare.I8, {1:-2}),
-        (bare.U16, bare.U16, {1:2}),
-        (bare.I16, bare.I16, {1:-2}),
-        (bare.U32, bare.U32, {1:2}),
-        (bare.I32, bare.I32, {1:-2}),
-        (bare.U64, bare.U64, {1:2}),
-        (bare.I64, bare.I64, {1:-2}),
-        (bare.UInt, bare.UInt, {1:2}),
-        (bare.Int, bare.Int, {1:-2}),
+        (bare.U8, bare.U8, {1: 2}),
+        (bare.I8, bare.I8, {1: -2}),
+        (bare.U16, bare.U16, {1: 2}),
+        (bare.I16, bare.I16, {1: -2}),
+        (bare.U32, bare.U32, {1: 2}),
+        (bare.I32, bare.I32, {1: -2}),
+        (bare.U64, bare.U64, {1: 2}),
+        (bare.I64, bare.I64, {1: -2}),
+        (bare.UInt, bare.UInt, {1: 2}),
+        (bare.Int, bare.Int, {1: -2}),
         (bare.Bool, bare.Bool, {True: False}),
         (bare.Bool, bare.Bool, {True: False}),
-    ]
+    ],
 )
 def test_all_types(key_type, value_type, data):
     anon_map = map(key_type, value_type)
@@ -63,4 +72,3 @@ def test_all_types(key_type, value_type, data):
     b = x.pack()
     x2 = anon_map.unpack(io.BytesIO(b))
     assert x == x2
-

{pybare-1.2.3 → pybare-1.2.5}/bare/test_misc.py

@@ -3,10 +3,14 @@ from bare import Enum, UInt, Void, Str
 import io
 import pytest
 
+__all__ = []
+
+
 class MyEnum(Enum):
     A = 1
     B = 2
 
+
 def test_enum_basic():
     b = MyEnum.A.pack()
     a = MyEnum.unpack(io.BytesIO(b))
@@ -16,15 +20,18 @@ def test_enum_basic():
         b = UInt(3).pack()
         MyEnum.unpack(io.BytesIO(b))
 
+
 class MyVoid(Void):
     ...
 
+
 def test_custom_void():
     x = MyVoid()
     b = x.pack()
     x2 = MyVoid.unpack(io.BytesIO(b))
     assert x == x2
-    assert b == b''
+    assert b == b""
+
 
 def test_void():
     x = Void()
@@ -33,9 +40,10 @@ def test_void():
     assert x == x2
     assert len(b) == 0
 
+
 def test_str():
     x = Str("Hello, world")
     b = x.pack()
     x2 = Str.unpack(io.BytesIO(b))
     assert x == x2
-    assert b == b'\x0cHello, world'
+    assert b == b"\x0cHello, world"

pybare-1.2.5/bare/test_number.py

@@ -0,0 +1,51 @@
+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, 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.3 → pybare-1.2.5}/bare/test_union.py

@@ -3,98 +3,129 @@ import bare
 import io
 import pytest
 
+__all__ = []
+
+
 class MyUnion(Union, variants=(Str, Int)):
     ...
 
+
 def test_union_basic():
     x = MyUnion(Str("Hello"))
     b = x.pack()
-    assert b == b'\x00\x05Hello'
+    assert b == b"\x00\x05Hello"
     x2 = MyUnion.unpack(io.BytesIO(b))
     assert x == x2
     with pytest.raises(TypeError):
         x = MyUnion(True)
     with pytest.raises(TypeError):
-        MyUnion.unpack(io.BytesIO(b'\x02\x05Hello'))
+        MyUnion.unpack(io.BytesIO(b"\x02\x05Hello"))
 
     x = MyUnion(Int(16))
     b = x.pack()
-    assert b == b'\x01\x20'
+    assert b == b"\x01\x20"
     x2 = MyUnion.unpack(io.BytesIO(b))
     assert x == x2
 
+
 def test_anonymous_union():
     MyUnion = union(Str, Int)
     x = MyUnion(Str("Hello"))
     b = x.pack()
-    assert b == b'\x00\x05Hello'
+    assert b == b"\x00\x05Hello"
     x2 = MyUnion.unpack(io.BytesIO(b))
     assert x == x2
     with pytest.raises(TypeError):
         x = MyUnion(True)
 
+
 def test_explicit_discriminant_implicit_following():
     class MyUnion(Union, variants=(UnionVariant(Str, 4), Int)):
         ...
+
     x = MyUnion(Str("Hello"))
     b = x.pack()
-    assert b == b'\x04\x05Hello'
+    assert b == b"\x04\x05Hello"
     x2 = MyUnion.unpack(io.BytesIO(b))
     assert x == x2
     with pytest.raises(TypeError):
         x = MyUnion(True)
     with pytest.raises(TypeError):
-        MyUnion.unpack(io.BytesIO(b'\x02\x05Hello'))
+        MyUnion.unpack(io.BytesIO(b"\x02\x05Hello"))
 
     x = MyUnion(Int(16))
     b = x.pack()
-    assert b == b'\x05\x20'
+    assert b == b"\x05\x20"
     x2 = MyUnion.unpack(io.BytesIO(b))
     assert x == x2
 
+
 def test_explicit_discriminant_all_cases():
     class MyUnion(Union, variants=(UnionVariant(Str, 4), UnionVariant(Int, 10))):
         ...
+
     x = MyUnion(Str("Hello"))
     b = x.pack()
-    assert b == b'\x04\x05Hello'
+    assert b == b"\x04\x05Hello"
     x2 = MyUnion.unpack(io.BytesIO(b))
     assert x == x2
     with pytest.raises(TypeError):
         x = MyUnion(True)
     with pytest.raises(TypeError):
-        MyUnion.unpack(io.BytesIO(b'\x02\x05Hello'))
+        MyUnion.unpack(io.BytesIO(b"\x02\x05Hello"))
 
     x = MyUnion(Int(16))
     b = x.pack()
-    assert b == b'\x0a\x20'
+    assert b == b"\x0a\x20"
     x2 = MyUnion.unpack(io.BytesIO(b))
     assert x == x2
 
-class AllPrimativeTypes(Union, variants=(Str, Int, bare.UInt, bare.Bool, bare.F32,
-                                         bare.F64, bare.U8, bare.I8, bare.U16, bare.I16,
-                                         bare.U32, bare.I32, bare.U64, bare.I64,
-                                         bare.Data, bare.Void)):
+
+class AllPrimativeTypes(
+    Union,
+    variants=(
+        Str,
+        Int,
+        bare.UInt,
+        bare.Bool,
+        bare.F32,
+        bare.F64,
+        bare.U8,
+        bare.I8,
+        bare.U16,
+        bare.I16,
+        bare.U32,
+        bare.I32,
+        bare.U64,
+        bare.I64,
+        bare.Data,
+        bare.Void,
+    ),
+):
     ...
 
-@pytest.mark.parametrize('value,discriminant', [
-    (Str("Hello"), 0),
-    (Int(123), 1),
-    (bare.UInt(123), 2),
-    (bare.Bool(True), 3),
-    (bare.F32(123.5), 4),
-    (bare.F64(123.5), 5),
-    (bare.U8(123), 6),
-    (bare.I8(123), 7),
-    (bare.U16(123), 8),
-    (bare.I16(123), 9),
-    (bare.U32(123), 10),
-    (bare.I32(123), 11),
-    (bare.U64(123), 12),
-    (bare.I64(123), 13),
-    (bare.Data(b'123'), 14),
-    (bare.Void(), 15),
-])
+
+@pytest.mark.parametrize(
+    "value,discriminant",
+    [
+        (Str("Hello"), 0),
+        (Int(123), 1),
+        (bare.UInt(123), 2),
+        (bare.Bool(True), 3),
+        (bare.F32(123.5), 4),
+        (bare.F64(123.5), 5),
+        (bare.U8(123), 6),
+        (bare.I8(123), 7),
+        (bare.U16(123), 8),
+        (bare.I16(123), 9),
+        (bare.U32(123), 10),
+        (bare.I32(123), 11),
+        (bare.U64(123), 12),
+        (bare.I64(123), 13),
+        (bare.Data(b"123"), 14),
+        (bare.Void(), 15),
+    ],
+)
 def test_union_all_primative_types(value, discriminant):
     x = AllPrimativeTypes(value)
     b = x.pack()

{pybare-1.2.3 → pybare-1.2.5}/bare/util.py

@@ -1,11 +1,12 @@
-from typing import Generic, Type, TypeVar
+from typing import Type, TypeVar
+from .misc import Enum
 
 from .baretype import BAREType
 
 T = TypeVar("T", bound=BAREType)
 
 
-class Field(Generic[T]):
+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.
@@ -21,15 +22,15 @@ class Field(Generic[T]):
 
     attr: str
     name: str
-    ty: Type[BAREType[T]]
+    ty: Type[BAREType | Enum]
 
-    def __init__(self, ty: Type[BAREType[T]], attr: str | None = None):
+    def __init__(self, ty: Type[BAREType | Enum], 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]]:
+    def __get__(self, inst, _) -> T | Type[BAREType[T] | Enum]:
         if inst is None:
             return self.ty
         return inst.__dict__[self.attr]

pybare-1.2.5/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[project]
+name = "pybare"
+version = "1.2.5"
+description = "A BARE Encoding Library and Data Validation Library for Python."
+dependencies = []
+requires-python = ">= 3.10"
+authors = [
+    { name = "Noah Pederson", email = "noah@packetlost.dev" },
+]
+readme = "README.md"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.license]
+file = "LICENSE"
+
+[project.urls]
+Homepage = "https://sr.ht/~chiefnoah/pybare/"
+Repository = "https://git.sr.ht/~chiefnoah/pybare"
+Issues = "https://todo.sr.ht/~chiefnoah/pybare"
+Changelog = "https://git.sr.ht/~chiefnoah/pybare/tree/master/item/CHANGELOG.md"
+
+[tool]

pybare-1.2.3/PKG-INFO

@@ -1,99 +0,0 @@
-Metadata-Version: 2.1
-Name: pybare
-Version: 1.2.3
-Summary: A declarative implementation of BARE for Python
-Home-page: https://sr.ht/~chiefnoah/pybare/
-Author: Noah Pederson
-Author-email: noah@packetlost.dev
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# PyBARE
-[![builds.sr.ht status](https://builds.sr.ht/~chiefnoah/pybare.svg)](https://builds.sr.ht/~chiefnoah/pybare?)
-
-A declarative implementation of the [BARE](https://baremessages.org/) message
-format for Python 3.10+
-
----
-
-pybare is a general purpose library for strongly typed primitives in Python that
-supports serializing to and from BARE messages.
-
-```shell
-pip install pybare
-```
-
-## Goals
-
-* Provide a declarative structure for defining types
-* Validation on value updates
-* Support streaming messages
-
-## Status
-
-pybare fully implements all BARE types for both encoding and decoding. This
-includes reading multiple messages from the same `BinaryIO` stream.
-
-## Gotchas
-
-We use "Array" / "array" instead of "List" / "list" to avoid conflicts with Python's
-common builtin type of the same name.
-
-## Examples
-
-An example that defines the types used as an example in the RFC may be found in
-[`example.py`](./example.py)
-
-pybare currently requires you define your structures by hand. Examples can be
-found in the
-[tests](https://git.sr.ht/~chiefnoah/pybare/tree/master/bare/test_encoder.py).
-
-### Quickstart
-
-The general convention is type identifiers start with a *capital* letter and anonymous
-generating functions begin with a lowercase. This follows general "pythonic" style for
-classes vs functions.
-
-```python
-from bare import Struct, map, Str, UInt, optional, data, array, Void, struct, U8
-
-# Alternatively, class Data(size=64): ...
-PubKey = data(64) # 512 bits
-
-class User(Struct):
-    username = Field(Str)
-    userid = Field(Int)
-    email = Field(optional(Str))
-    keys = Field(map(Str, PubKey))
-    repos = Field(array(Str)) # variable length array
-    # anonymous array and struct
-    friends = Field(array(struct(name=Str, age=U8)))
-
-
-noah = User(username="chiefnoah", userid=1, email=Void(), keys={}, repos=[], friends=[])
-noah.username == 'chiefnoah'
-noah.username = 'someoneelse'
-noah.username == 'someoneelse'
-noah.userid == 1 # True
-noah.username = 1 # raise: bare.ValidationError
-noah.keys # {} (empty dict)
-noah.keys['my key'] = bytes(64) #\x00\x00...
-noah.keys['oops'] = bytes(1) # raise: bare.ValidationError
-noah.email == Void() # True
-noah.email = 12345 # raise: bare.ValidationError
-noah.pack() # \x00\x01 ... (binary data)
-```
-
-Note, you **must** wrap the desired type in a `Field` to get its 'magic' behavior.
-Class or instance fields that are not wrapped in a `Field` will be ignored by the `pack`
-and `unpack` methods.
-
----
-
-To contribute, send patches to [~chiefnoah/inbox@lists.sr.ht](mailto:~chiefnoah/inbox@lists.sr.ht)

pybare-1.2.3/bare/test_number.py

@@ -1,43 +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.3/pybare.egg-info/SOURCES.txt

@@ -1,25 +0,0 @@
-LICENSE
-README.md
-setup.py
-bare/__init__.py
-bare/barearray.py
-bare/barestruct.py
-bare/baretype.py
-bare/data.py
-bare/map.py
-bare/misc.py
-bare/number.py
-bare/test_barearray.py
-bare/test_barestruct.py
-bare/test_data.py
-bare/test_encoder.py
-bare/test_map.py
-bare/test_misc.py
-bare/test_number.py
-bare/test_union.py
-bare/union.py
-bare/util.py
-pybare.egg-info/PKG-INFO
-pybare.egg-info/SOURCES.txt
-pybare.egg-info/dependency_links.txt
-pybare.egg-info/top_level.txt

pybare-1.2.3/pybare.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

pybare-1.2.3/pybare.egg-info/top_level.txt

@@ -1 +0,0 @@
-bare

pybare-1.2.3/setup.cfg

@@ -1,4 +0,0 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-

pybare-1.2.3/setup.py

@@ -1,24 +0,0 @@
-import setuptools
-
-with open("README.md", "r") as fh:
-    long_description = fh.read()
-
-setuptools.setup(
-    name="pybare",  # Replace with your own username
-    version="1.2.3",
-    author="Noah Pederson",
-    author_email="noah@packetlost.dev",
-    description="A declarative implementation of BARE for Python",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    url="https://sr.ht/~chiefnoah/pybare/",
-    packages=setuptools.find_packages(),
-    classifiers=[
-        "Programming Language :: Python :: 3.10",
-        "Programming Language :: Python :: 3.11",
-        "Programming Language :: Python :: 3.12",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: OS Independent",
-    ],
-    python_requires=">=3.10",
-)