Metadata-Version: 2.1
Name: attrs2bin
Version: 0.0.1
Summary: Binary serializer for attrs-based classes
Home-page: https://github.com/fvicent/attrs2bin
Author: Francisco Vicent
Author-email: franciscovicent@outlook.com
License: UNKNOWN
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Development Status :: 3 - Alpha
Classifier: Programming Language :: Rust
Requires-Python: >=3.6
Description-Content-Type: text/markdown
Requires-Dist: zope.interface
Requires-Dist: zope.component
Requires-Dist: attrs

# attrs2bin
`attrs2bin` is a Python library that lets you serialize/deserialize your [`attrs`](https://www.attrs.org/en/stable/)-based classes to/from a byte stream. It is compatible with Rust's [`bincode`](https://github.com/servo/bincode), so you can seralize objects in Python, send the resulting byte stream through a socket or any other transport and deserialize it back to a Rust object. It can also deserialize objects from a socket (see below).

# Example

`attrs2bin` provides just two simple funcions: `serialize()`, which takes an object and returns a byte stream, and `deserialize()`, that takes a byte stream and an `attrs`-based class and returns an object.

```import attr
import attrs2bin

@attr.s(auto_attribs=True)
class Sprite:
    name: str
    x: int
    y: int

my_sprite = Sprite("My sprite", 35, 70)
serialized = attrs2bin.serialize(my_sprite)
deserialized = attrs2bin.deserialize(serialized, Sprite)
assert my_sprite == deserialized
```

# What can be serialized?

Objects of any `attrs`-based class can be serialized, as long as all their fields have a type (using type annotations or `attr.ib(type=...)`). `attrs2bin` ships with serializer for the following types:

* `int`
* `float`
* `bytes`
* `str`
* `bool`

You can create and register your own serializers for specific types by creating a class that implements `attrs2bin.interfaces.ITypeSerializer` and calling `attrs2bin.register_serializer()`.

# Deserializing from a socket

Instead of `deserialize(bytes, cls)`, you can use `deserialize_from_socket(sck, cls)`, which will read the necessary bytes from a socket and return a Python object. `sck` must be any object that implements `attrs2bin.interfaces.IReadableSocket`.

# Rust compatibility

The serializers that ships with `attrs2bin` are all compatible with Rust's [`bincode`](https://github.com/servo/bincode) library. Keep under your pillow the following table in order to create compatible types between Python and Rust:

| Python type                   | Rust type     |
| ---------------------------   |:-------------:|
| `int` / `attrs2bin.SignedInt` | `i64`         |
| `attrs2bin.UnsignedInt`       | `u64`         |
| `float` / `attrs2bin.Float64` | `f64`         |
| `attrs2bin.Float32`           | `f32`         |
| `bytes`                       | `Vec<u8>`     |
| `str`                         | `String`      |
| `bool`                        | `bool`        |

