protonbites 🧪 EXPR1

Most sane way to store JSON data. Simple, light, strongly-typed and secure. (Probably, overall)

Step 1. Create a dataclass.

from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int

For floats and ints, you can use typing.Annotated[int, '<dtype>'] where <dtype> is the desired datatype. Below are the avilable dtypes:

ints

• int8 / uint8
• int16 / uint16
• int32 / uint32
• int64 / uint64

floats

• float32
• float64

Step 2. Create a schema from the dataclass.

from protonbites import get_schema

schema = get_schema(Person)

Step 3. Use the schema to encode/decode data.

# Init a new dataclass
person = Person(name="Jesse Pinkman", age=28)

encoded = schema.encode(person)
decoded = schema.decode(encoded)

assert isinstance(decoded, Person)

API Documentation incomplete

Oopsy daisy.

def encode

def encode(
    obj: PythonBackendDataTypes, 
    /, 
    *,
    force_keep_str: bool = False
) -> bytes

Encode data to a proton.

Args:

• obj (PythonBackendDataTypes): Object.
• force_keep_str (bool): Force keep the string? Usually, when the expected text length is more than 102 characters, we use gzip to compress the text data. If you wish to keep the string, set this to True.

Simple Example:

encode({
    "name": "Mr. Penguin",
    "tags": ["depressed"],
    "friends": [
        {
            "name": "Fernando Miguel",
            "tags": ["dancing", "noot"]
        }
    ]
})
# => b"\x01\x0f'Mr. Penguin'\x11\x03\x0f'depressed'\x11\x04\x11\x03\x01\x0f'Fernando Miguel'\x11\x03\x0f'dancing'\x11\x0f'noot'\x11\x04\x11\x02\x11\x04\x11\x02"

encode({ "text": "what the fish " * 9_999 })
# => b'\x01\x0f1f8b0800a6ed516602ffe…bf2c1f2a24c7aad4220200\x11\x02'

Example using custom ints and floats:

from protonbites import uint8, float32

encode({
    "a": uint8(10),
    "b": float32(10.98535)
})

def decode

def decode(__c: bytes, /) -> PythonBackendTypes

Decode the data.

Args:

• __c: The encoded data.

Example:

a = decode(b"\x01…\x02")
# => [ …, …, … ]

reveal_type(a)  # PythonBackendDataTypes (type_checking)

# To ensure the decoded data is the entrypoint
b = decoded_safely(a)
reveal_type(b)  # list (type_checking)

def get_schema

get_schema(__dc: type[T], /) -> Schema[T]
where T: DataclassProtocol

Args:

• __dc: The dataclass.

@dataclass
class Person:
    name: str
    age: int

schema = get_schema()
schema.encode(Person(name="Jesse Pinkman", age=28))

(c) 2024 AWeirdDev