hit9 / bitproto Goto Github PK

# b_bp.py

# Code generated by bitproto. DO NOT EDIT.


import json
from dataclasses import dataclass, field
from typing import ClassVar, Dict, List, Union
from enum import IntEnum, unique

from bitprotolib import bp


@unique
class X(IntEnum): # 1bit
    OK = 0


# Aliases for backwards compatibility
OK: X = X.OK


_X_VALUE_TO_NAME_MAP: Dict[X, str] = {
    X.OK: "OK",
}

def bp_processor_X() -> bp.Processor:
    return bp.EnumProcessor(bp.Uint(1))

# a_bp.py


import json
from dataclasses import dataclass, field
from typing import ClassVar, Dict, List, Union
from enum import IntEnum, unique

from bitprotolib import bp

import b_bp as b


@dataclass
class A(bp.MessageBase):
    # Number of bytes to serialize class A
    BYTES_LENGTH: ClassVar[int] = 1

    x: Union[int, b.X] = b.X.b.OK          # !!!!!!!!!!!!! ERROR here
    # This field is a proxy to hold integer value of enum field 'x'
    _enum_field_proxy__x: int = field(init=False, repr=False) # 1bit

    def __post_init__(self):
        # initialize handling of enum field 'x' as `enum.IntEnum`
        if not isinstance(getattr(A, "x", False), property):
            self._enum_field_proxy__x = self.x
            A.x = property(A._get_x, A._set_x)  # type: ignore

    @staticmethod
    def dict_factory(kv_pairs):
        return {k: v for k, v in kv_pairs if not k.startswith('_enum_field_proxy__')}

    def _get_x(self) -> b.X:
        """property getter for enum proxy field"""
        return b.X(self._enum_field_proxy__x)

    def _set_x(self, val):
        """property setter for enum proxy field"""
        self._enum_field_proxy__x = val

    def bp_processor(self) -> bp.Processor:
        field_processors: List[bp.Processor] = [
            bp.MessageFieldProcessor(1, b.bp_processor_X()),
        ]
        return bp.MessageProcessor(False, 1, field_processors)

    def bp_set_byte(self, di: bp.DataIndexer, lshift: int, b: bp.byte) -> None:
        if di.field_number == 1:
            self.x |= (b.X(b) << lshift)
        return

    def bp_get_byte(self, di: bp.DataIndexer, rshift: int) -> bp.byte:
        if di.field_number == 1:
            return (self.x >> rshift) & 255
        return bp.byte(0)  # Won't reached

    def bp_get_accessor(self, di: bp.DataIndexer) -> bp.Accessor:
        return bp.NilAccessor() # Won't reached

    def encode(self) -> bytearray:
        """
        Encode this object to bytearray.
        """
        s = bytearray(self.BYTES_LENGTH)
        ctx = bp.ProcessContext(True, s)
        self.bp_processor().process(ctx, bp.NIL_DATA_INDEXER, self)
        return ctx.s

    def decode(self, s: bytearray) -> None:
        """
        Decode given bytearray s to this object.
        :param s: A bytearray with length at least `BYTES_LENGTH`.
        """
        assert len(s) >= self.BYTES_LENGTH, bp.NotEnoughBytes()
        ctx = bp.ProcessContext(False, s)
        self.bp_processor().process(ctx, bp.NIL_DATA_INDEXER, self)

    def bp_process_int(self, di: bp.DataIndexer) -> None:
        return

import json
from dataclasses import dataclass, field
from typing import ClassVar, Dict, List
from enum import IntEnum, unique

from bitprotolib import bp


@unique
class MyEnum(IntEnum):
    MY_ENUM_UNKNOWN = 0
    MY_ENUM_ONE = 1
    MY_ENUM_TWO = 2
    MY_ENUM_THREE = 3


_MYENUM_VALUE_TO_NAME_MAP: Dict[MyEnum, str] = {
    MyEnum.MY_ENUM_UNKNOWN: "MY_ENUM_UNKNOWN",
    MyEnum.MY_ENUM_ONE: "MY_ENUM_ONE",
    MyEnum.MY_ENUM_TWO: "MY_ENUM_TWO",
    MyEnum.MY_ENUM_THREE: "MY_ENUM_THREE",
}


def bp_processor_MyEnum() -> bp.Processor:
    return bp.EnumProcessor(bp.Uint(2))


@dataclass
class EnumContainer(bp.MessageBase):
    # Number of bytes to serialize class EnumContainer
    BYTES_LENGTH: ClassVar[int] = 1
 
    # based on https://stackoverflow.com/a/61709025/1169220
    my_enum: MyEnum = MyEnum.MY_ENUM_UNKNOWN
    _my_enum: int = field(init=False, repr=False)

    def __post_init__(self):
        if not isinstance(getattr(EnumContainer, "my_enum", False), property):
            self._my_enum = self.my_enum
            EnumContainer.my_enum = property(EnumContainer._get_my_enum, EnumContainer._set_my_enum)

    def _get_my_enum(self):
        return MyEnum(self._my_enum)

    def _set_my_enum(self, val):
        self._my_enum = val

...

import enums_bp as bp

enum_container = bp.EnumContainer(my_enum=bp.MyEnum.MY_ENUM_ONE)
s = enum_container.encode()
enum_container_new = bp.EnumContainer()
enum_container_new.decode(s)
assert enum_container_new.my_enum == enum_container.my_enum
assert enum_container_new.encode() == s
assert isinstance(enum_container.my_enum, bp.MyEnum)
assert isinstance(enum_container_new.my_enum, bp.MyEnum)
assert enum_container.my_enum is bp.MyEnum.MY_ENUM_ONE
assert enum_container_new.my_enum is bp.MyEnum.MY_ENUM_ONE