pybare 1.2.2__tar.gz → 1.2.4__tar.gz

pybare-1.2.4/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.1
+Name: pybare
+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
+
+# 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.
+
+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
+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.2 → pybare-1.2.4}/README.md

@@ -2,7 +2,7 @@
 [![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.11+
+format for Python 3.10+
 
 ---
 
@@ -24,36 +24,45 @@ pip install pybare
 pybare fully implements all BARE types for both encoding and decoding. This
 includes reading multiple messages from the same `BinaryIO` stream.
 
-### TODO
+It is well tested and in use on production systems.
 
-- [ ] Codegen based on `.schema` files
-- [ ] Better documentation
-- [ ] More tests
-- [ ] Fast C implementation for encoding
+## 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
+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 = Filed(Str)
+    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=[])
+noah = User(username="chiefnoah", userid=1, email=Void(), keys={}, repos=[], friends=[])
 noah.username == 'chiefnoah'
 noah.username = 'someoneelse'
 noah.username == 'someoneelse'

{pybare-1.2.2 → pybare-1.2.4}/bare/__init__.py

@@ -7,7 +7,7 @@ BARE RFC.
 """
 
 from .barearray import Array, array
-from .barestruct import Field, Struct
+from .barestruct import Field, Struct, struct
 from .baretype import BAREType
 from .data import Data, data
 from .map import Map, map
@@ -43,6 +43,7 @@ __all__ = [
     "array",
     "Field",
     "Struct",
+    "struct",
     "Map",
     "map",
 ]

pybare-1.2.4/bare/_examples/terminated.bin

@@ -0,0 +1 @@
+

{pybare-1.2.2 → 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.2 → pybare-1.2.4}/bare/barestruct.py

@@ -1,11 +1,15 @@
 from __future__ import annotations
 
-from typing import Any, BinaryIO, _ProtocolMeta
+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"]
+
 
-__all__ = ["Struct"]
+T = TypeVar("T")
 
 
 class StructMeta(_ProtocolMeta, type):
@@ -77,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)
@@ -118,3 +120,25 @@ class Struct(BAREType, metaclass=StructMeta):
                     return False
             return True
         return NotImplemented
+
+
+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
+    value being the field type. The field type is implicitly wrapped in a `Field`.Field
+
+    Proper usage of this function is as follows:
+
+    ```
+    MyStruct = struct(a=UInt, b=Str)
+    ```
+
+    Note that the name of the class is unspecified, use at your own risk.
+    """
+    name = "Struct_{}_anonymous".format("_".join(kwargs.keys()))
+    namespace = StructMeta.__prepare__(name, (Struct,))
+    namespace.update({field: Field(ty) for field, ty in kwargs.items()})  # type: ignore
+    AnonymousStruct = StructMeta.__new__(StructMeta, name, (Struct,), namespace)
+    StructMeta.__init__(AnonymousStruct, name, (Struct,), namespace)
+    return AnonymousStruct

{pybare-1.2.2 → 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.2 → 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.2 → 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.2 → 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.2 → pybare-1.2.4}/bare/test_barestruct.py

@@ -1,16 +1,19 @@
 import io
-from bare import Struct, UInt, Str, Field
+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)
@@ -22,3 +25,11 @@ def test_nested_struct():
     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.2 → 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.2 → 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.2 → 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.2 → 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.2 → 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.2/PKG-INFO

@@ -1,92 +0,0 @@
-Metadata-Version: 2.1
-Name: pybare
-Version: 1.2.2
-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.11+
-
----
-
-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.
-
-### TODO
-
-- [ ] Codegen based on `.schema` files
-- [ ] Better documentation
-- [ ] More tests
-- [ ] Fast C implementation for encoding
-
-## Examples
-
-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
-
-```python
-from bare import Struct, map, Str, UInt, optional, data, array, Void
-
-# Alternatively, class Data(size=64): ...
-PubKey = data(64) # 512 bits
-
-class User(Struct):
-    username = Filed(Str)
-    userid = Field(Int)
-    email = Field(optional(Str))
-    keys = Field(map(Str, PubKey))
-    repos = Field(array(Str)) # variable length array
-
-
-noah = User(username="chiefnoah", userid=1, email=Void(), keys={}, repos=[])
-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.2/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.2/pybare.egg-info/PKG-INFO

@@ -1,92 +0,0 @@
-Metadata-Version: 2.1
-Name: pybare
-Version: 1.2.2
-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.11+
-
----
-
-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.
-
-### TODO
-
-- [ ] Codegen based on `.schema` files
-- [ ] Better documentation
-- [ ] More tests
-- [ ] Fast C implementation for encoding
-
-## Examples
-
-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
-
-```python
-from bare import Struct, map, Str, UInt, optional, data, array, Void
-
-# Alternatively, class Data(size=64): ...
-PubKey = data(64) # 512 bits
-
-class User(Struct):
-    username = Filed(Str)
-    userid = Field(Int)
-    email = Field(optional(Str))
-    keys = Field(map(Str, PubKey))
-    repos = Field(array(Str)) # variable length array
-
-
-noah = User(username="chiefnoah", userid=1, email=Void(), keys={}, repos=[])
-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.2/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.2/pybare.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

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

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

pybare-1.2.2/setup.cfg

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

pybare-1.2.2/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.2",
-    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",
-)