pybare 1.2.3__tar.gz → 1.2.4__tar.gz

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

@@ -1,18 +1,40 @@
 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.4
+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?)
@@ -40,6 +62,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.4}/README.md

@@ -24,6 +24,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.4/bare/_examples/terminated.bin

@@ -0,0 +1 @@
+

{pybare-1.2.3 → pybare-1.2.4}/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.4}/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: Dict[str, 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.4}/bare/baretype.py

@@ -7,17 +7,14 @@ 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.3 → pybare-1.2.4}/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.4}/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.4}/bare/test_barearray.py

@@ -5,11 +5,11 @@ import bare
 import pytest
 import io
 
+
 def test_2d_array_unsized():
-    class InnerArray(Array, inner=UInt):
-        ...
-    class My2DArray(Array, inner=InnerArray):
-        ...
+    class InnerArray(Array, inner=UInt): ...
+
+    class My2DArray(Array, inner=InnerArray): ...
 
     input = [[1, 2], [3, 4]]
     x = My2DArray(input)
@@ -18,6 +18,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 +28,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,9 +43,9 @@ 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):
-        ...
+    class MyArry(Array, inner=UInt, size=3): ...
 
     input = [1, 2, 3]
     x = MyArry(input)
@@ -56,24 +58,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.4}/bare/test_barestruct.py

@@ -1,16 +1,19 @@
 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)
@@ -23,6 +26,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.4}/bare/test_data.py

@@ -3,27 +3,27 @@ import io
 
 
 def test_data_sized():
-    class SizedData(Data, size=5):
-        ...
+    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):
-        ...
+    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.4}/bare/test_map.py

@@ -5,8 +5,8 @@ import io
 import pytest
 
 
-class MyMap(Map, key_type=Str, value_type=Int):
-    ...
+class MyMap(Map, key_type=Str, value_type=Int): ...
+
 
 def test_basic_map():
     x = MyMap({"Hello": 123, "abc": 456})
@@ -16,6 +16,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 +26,41 @@ 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):
-        ...
+
+    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 +68,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.4}/bare/test_misc.py

@@ -3,10 +3,12 @@ from bare import Enum, UInt, Void, Str
 import io
 import pytest
 
+
 class MyEnum(Enum):
     A = 1
     B = 2
 
+
 def test_enum_basic():
     b = MyEnum.A.pack()
     a = MyEnum.unpack(io.BytesIO(b))
@@ -16,15 +18,17 @@ def test_enum_basic():
         b = UInt(3).pack()
         MyEnum.unpack(io.BytesIO(b))
 
-class MyVoid(Void):
-    ...
+
+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 +37,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.4/bare/test_number.py

@@ -0,0 +1,49 @@
+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-1.2.4}/bare/test_union.py

@@ -3,98 +3,123 @@ import bare
 import io
 import pytest
 
-class MyUnion(Union, variants=(Str, Int)):
-    ...
+
+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)):
-        ...
+    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))):
-        ...
+    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)):
-    ...
-
-@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),
-])
+
+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),
+    ],
+)
 def test_union_all_primative_types(value, discriminant):
     x = AllPrimativeTypes(value)
     b = x.pack()

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

@@ -5,7 +5,7 @@ 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,9 +21,9 @@ class Field(Generic[T]):
 
     attr: str
     name: str
-    ty: Type[BAREType[T]]
+    ty: Type[BAREType]
 
-    def __init__(self, ty: Type[BAREType[T]], attr: str | None = None):
+    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

pybare-1.2.4/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[project]
+name = "pybare"
+version = "1.2.4"
+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",
-)