@message
@dataclass
class Box:
    box: Optional['Box'] = field(1)
    value: int = field(2)

from faker import Faker
from dataclasses import dataclass
from pure_protobuf.dataclasses_ import field, message

Faker.seed(0)
fake = Faker()


@message
@dataclass
class Head():
    msgId: str = field(1)
    msgCode: str = field(2)
    guid: str = field(3)
    src: str = field(4)
    ts: int = field(5)

    @staticmethod
    def fakeMe():
        return Head(fake.md5(),
                fake.pystr(min_chars=5, max_chars=5),
                fake.ean(length=13),
                fake.pystr(min_chars=1, max_chars=1),
                int(time()*1000)
            )

@message
@dataclass
class Message():
    head: Head = field(1)
    # data: Data = field(2)
    status: bool = field(2)

    def fakeMe(self):
        self.head = Head.fakeMe()
        # self.data = Data.fakeMe()
        self.bool = fake.pybool()
        return self

import time, sys, orjson, message_pb2
from object_gen import create_dummy_obj
from dto.device_message import Message          # this is my data calss

def measure_serialize_deserialize(obj, format):
  ser_fun = ser_obj.get(format)

  deser_fun = deser_obj.get(format)

  # serialize and measure time
  start_time = time.time()
  ser_data = ser_fun(obj)
  time_taken_ser = time.time() - start_time
  mem_ser = sys.getsizeof(ser_data)

  # deserialize and measure time
  start_time = time.time()
  deser_data = deser_fun(ser_data, Message)
  time_taken_deser = time.time() - start_time

  return (time_taken_ser, time_taken_deser, mem_ser)


def serialize_json(obj):
  return orjson.dumps(obj)



def deserialize_json(byteArr, klass):
  return orjson.loads(byteArr)


def serialize_proto(obj):
  return obj.dumps()


def deserialize_proto(byteArr, klass):
  return klass.loads(byteArr)


def serialize_avro(obj):
  pass

def deserialize_avro(byteArr, klass):
  pass


ser_obj = {
  "J": serialize_json,
  "P": serialize_proto,
  "A": serialize_avro,
}

deser_obj = {
  "J": deserialize_json,
  "P": deserialize_proto,
  "A": deserialize_avro,
}


def runBenchMarks(numberOfMsgs, format):

  ser_times = []
  deser_times = []
  memory_usage_plain = []
  memory_usage_ser = []

  for i in range(1, numberOfMsgs + 1):
    # create new object basis on the format.
    obj = create_dummy_obj(format)
    memory_usage_plain.append(sys.getsizeof(obj))
    ser_time, deser_time, mem_ser =  measure_serialize_deserialize(obj, format)
    ser_times.append(ser_time)
    deser_times.append(deser_time)
    memory_usage_ser.append(mem_ser)

  # return values
  return ser_times, deser_times, memory_usage_plain, memory_usage_ser

from dataclasses import dataclass

from pure_protobuf.dataclasses_ import field, message
from pure_protobuf.types import int32


@message
@dataclass
class SearchRequest:
    query: str = field(1, default="")
    page_number: int32 = field(2, default=int32(0))
    result_per_page: int32 = field(3, default=int32(0))


obj = SearchRequest(
    query="hello",
    page_number=int32(1),
    result_per_page=int32(10),
)
serialized = obj.dumps()
deserialized = SearchRequest.loads(serialized)
print(f"{serialized=}")
print(f"{deserialized=}")

@message
@dataclass
class SearchRequest:
    query: str = field(1, default="")
    page_number: int32 = field(2, default=int32(0))
    result_per_page: int32 = field(3, default=int32(0))

    def dumps(self) -> bytes:
        return getattr(super(), "dumps")()

    @classmethod
    def loads(cls, data: bytes) -> "SearchRequest":
        return getattr(super(), "loads")(data)

from dataclasses import dataclass
from typing import Union

from pure_protobuf.dataclasses_ import field, message, oneof
from pure_protobuf.types import double, uint32, uint64


@message
@dataclass
class MessageWithOneofs:
    message_data: Union[uint64, double] = oneof()
    message_id: uint32 = field(1)
    message_desc: str = field(2)
    counter: uint64 = field(3, oneof="message_data")
    value: uint64 = field(4, oneof="message_data")

def validate(self, value: Any): 
  if not isinstance(value, (bytes, bytearray, memoryview)):
    try:
      memoryview(value)
    except TypeError as exc:
      raise ValueError('a byte string is expected') from exc

import struct

from google.protobuf import message
from itertools import count
from pure_protobuf import types as pureprototype
from pure_protobuf.dataclasses_ import SERIALIZERS
from pure_protobuf.serializers import Serializer
from pure_protobuf.enums import WireType
from pure_protobuf.io_ import IO
from pure_protobuf.serializers import signed_varint_serializer
from typing import NewType, Any, TypeVar, Type

pureprototype.int32 = NewType("int32", int)
pureprototype.int64 = NewType("int64", int)

T = TypeVar('T')


class IntNSerializer(Serializer):
    wire_type = WireType.VARINT
    local_int2byte = struct.Struct('>B').pack

    def __init__(self, sign_bit: int, mask: int, int_n: Type[T], int_n_range: int):
        self.sign_bit = sign_bit
        self.mask = mask,
        self.int_n = int_n
        self.int_n_range = int_n_range

    def validate(self, value: Any):
        signed_varint_serializer.validate(value)
        if not -self.int_n_range <= value <= self.int_n_range:
            raise ValueError("value is out of  integer range")

    def dump(self, value: Any, io: IO):
        if value < 0:
            value += (1 << 64)
        bits = value & 0x7f
        value >>= 7
        while value:
            io.write(self.local_int2byte(0x80 | bits))
            bits = value & 0x7f
            value >>= 7
        return io.write(self.local_int2byte(bits))

    def load(self, io: IO) -> Any:
        value = 0
        for shift in count(0, 7):
            (byte,) = io.read(1)
            value |= (byte & 0x7F) << shift
            if not byte & 0x80:
                value &= self.mask
                value = (value ^ self.sign_bit) - self.sign_bit
                return self.int_n(value)
            shift += 7
            if shift >= 64:
                raise message.DecodeError('Too many bytes when decoding varint.')
        return value


SERIALIZERS.update(
    {
        pureprototype.int32: IntNSerializer(
            sign_bit=1 << (32 - 1),
            mask=(1 << 32) - 1,
            int_n=pureprototype.int32,
            int_n_range=0x7FFFFFFF
        )
    }
)
SERIALIZERS.update(
    {
        pureprototype.int64: IntNSerializer(
            sign_bit=1 << (64 - 1),
            mask=(1 << 64) - 1,
            int_n=pureprototype.int64,
            int_n_range=0x7FFFFFFF_FFFFFFFF,
        )
    }
)

def optional_field(number: int) -> dataclasses.Field:
    return field(number, default=None)

@message
@dataclass
class DeviceToServerMessage:
    parking_report: Optional[DeviceDataRequest] = optional_field(1)
    firmware_update_check: Optional[FirmwareUpdateRequest] = optional_field(2)
    reg_request: Optional[DeviceRegistrationRequest] = optional_field(3)
    auth_request: Optional[DeviceAuthenticationRequest] = optional_field(4)
    # For mesh network
    mesh_src: Optional[str] = optional_field(13)

@message
@dataclass
class Message:
    foo: List[int32] = field(1, default_factory=list, packed=False)