Enumerations

class Enum(int, enum.Enum):
    """Protocol buffers enumeration base class. Acts like `enum.IntEnum`."""
    
    @classmethod
    def from_string(cls, name: str) -> int:
        """
        Return the value which corresponds to the string name.
        
        Args:
            name: The string name of the enum value
            
        Returns:
            The integer value corresponding to the name
            
        Raises:
            ValueError: If the name is not found in the enum
        """

def enum_field(number: int, group: Optional[str] = None) -> Any:
    """
    Create an enumeration field with the given protobuf field number.
    
    Args:
        number: Protobuf field number (must be unique within the message)
        group: Optional one-of group name if this field is part of a one-of
        
    Returns:
        A dataclass field configured for enum values
    """

import betterproto
from dataclasses import dataclass

class Status(betterproto.Enum):
    UNKNOWN = 0
    PENDING = 1
    APPROVED = 2
    REJECTED = 3

@dataclass
class Request(betterproto.Message):
    id: str = betterproto.string_field(1)
    status: Status = betterproto.enum_field(2)
    priority: Priority = betterproto.enum_field(3, group="urgency")

# Create a request with enum values
request = Request(
    id="req-123",
    status=Status.PENDING
)

# Access enum values
print(request.status)  # Status.PENDING (displays as 1)
print(request.status.name)  # "PENDING"
print(request.status.value)  # 1

# Convert from string names
status = Status.from_string("APPROVED")
print(status)  # Status.APPROVED

# Handle unknown string names
try:
    bad_status = Status.from_string("INVALID")
except ValueError as e:
    print(f"Error: {e}")  # Error: Unknown value INVALID for enum Status

# Enums serialize as their integer values
request = Request(id="req-123", status=Status.APPROVED)

# JSON serialization uses enum names
json_data = request.to_json()
print(json_data)  # {"id": "req-123", "status": "APPROVED"}

# Dictionary conversion also uses names by default
dict_data = request.to_dict()
print(dict_data)  # {"id": "req-123", "status": "APPROVED"}

# Parse from JSON with enum names
request_from_json = Request().from_json('{"id": "req-456", "status": "REJECTED"}')
print(request_from_json.status)  # Status.REJECTED

@dataclass
class MultiStatus(betterproto.Message):
    statuses: List[Status] = betterproto.enum_field(1)

# Create with multiple enum values
multi = MultiStatus(statuses=[Status.PENDING, Status.APPROVED, Status.REJECTED])

# JSON serialization
json_data = multi.to_json()
print(json_data)  # {"statuses": ["PENDING", "APPROVED", "REJECTED"]}

class Priority(betterproto.Enum):
    LOW = 0
    MEDIUM = 1
    HIGH = 2

class Urgency(betterproto.Enum):
    NORMAL = 0
    URGENT = 1
    CRITICAL = 2

@dataclass
class Task(betterproto.Message):
    name: str = betterproto.string_field(1)
    
    # One-of group for priority specification
    priority: Priority = betterproto.enum_field(2, group="priority_level")
    urgency: Urgency = betterproto.enum_field(3, group="priority_level")

# Use one-of enums
task = Task(name="Important Task", priority=Priority.HIGH)

# Check which one-of field is set
field_name, field_value = betterproto.which_one_of(task, "priority_level")
print(f"Priority field: {field_name} = {field_value}")  # priority = Priority.HIGH

# Enums work seamlessly with binary serialization
task = Task(name="Test", priority=Priority.MEDIUM)

# Serialize to binary
binary_data = bytes(task)

# Parse from binary - enum values are automatically converted
parsed_task = Task().parse(binary_data)
print(type(parsed_task.priority))  # <enum 'Priority'>
print(parsed_task.priority)  # Priority.MEDIUM

# Enum type constant
TYPE_ENUM: str = "enum"